This article walks through converting a Go‑based TCP private‑protocol server to support WebSocket on the same port, covering library selection, client and server implementation, request upgrading, and a complete usage example with code snippets.
An extensive compilation of 50 essential computer networking interview questions covering HTTP status codes, request methods, network architecture, DNS resolution, TCP/UDP protocols, security concepts like CSRF and XSS, and detailed explanations of TCP handshakes, congestion control, and encryption mechanisms.
This article explains TCP’s connection establishment and termination processes, details the roles of half‑ and full‑connection queues in Linux, demonstrates how to simulate and detect queue overflows using tools like netstat, ss, hping3 and ab, and provides kernel tuning parameters to mitigate SYN flood and TIME_WAIT issues.
The article explains NVMe over Fabrics (NVMe‑oF), its evolution from PCIe‑based NVMe, the various transport mechanisms such as RDMA, Fibre Channel and TCP, and why networking is essential for high‑performance, shared, and disaggregated storage in modern data centers.
This article explains the complete kernel‑level implementation of the TCP three‑way handshake, covering server listen queue allocation, client connect state handling, SYN/SYN‑ACK processing, syncookie protection, timer management, socket creation, and the accept path, with detailed code examples.
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 how to design and implement a secure gRPC gateway using OpenResty, analyzes performance bottlenecks such as excessive TIME_WAIT connections, and provides practical kernel and Nginx/OpenResty tuning steps to achieve long‑lived connections and lower latency.
On Linux, the client port used in a TCP connection is selected either by the kernel during the connect system call—randomly scanning the ip_local_port_range while respecting reserved ports—or by a prior bind call, with detailed kernel functions such as inet_hash_connect and __inet_hash_connect governing the process.
This article provides a clear, step‑by‑step explanation of network layering, covering the purpose and function of each layer—from the physical medium up to the application protocols—while illustrating concepts with diagrams and practical examples.
This article traces the development of the HTTP protocol from its earliest 0.9 version through HTTP/1.1, HTTP/2, and finally HTTP/3 built on QUIC, highlighting how each iteration improved speed, efficiency, and mitigated head‑of‑line blocking while introducing new challenges.
This article reviews Google’s pioneering SPDY protocol, its key features and impact on HTTP/2, then explores the disruptive QUIC protocol built on UDP, detailing its connection setup, Diffie‑Hellman encryption, multiplexing, connection migration, and other enhancements that boost web performance.
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.
This article examines the challenges of message loss in live‑streamed online classrooms, analyzes why pushes can fail, and proposes a comprehensive reliability strategy—including TCP fundamentals, multi‑channel redundancy, sequence‑based ordering, hole‑pulling, and configurable back‑end mechanisms—to achieve near‑100% delivery.
This article provides a comprehensive guide to TCP’s core mechanisms, covering connection establishment via the three‑way handshake, graceful termination with the four‑step teardown, half‑open and half‑close scenarios, simultaneous open/close, initial sequence numbers, and detailed state‑transition diagrams, all illustrated with diagrams.
This article explains the complete process from entering a URL to rendering a web page, covering URL parsing, DNS resolution, TCP three‑way handshake and four‑way teardown, HTTP request/response structure, and browser rendering, while also clarifying TIME_WAIT and related socket states.
This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.
This article details a large‑scale C10K performance test of Dubbo, analyzes why service calls time out under thousands of concurrent consumers, identifies heartbeat‑induced Netty thread saturation and TCP full‑connection‑queue overflow as root causes, and presents concrete optimizations that dramatically improve latency and stability.
This article explains TCP's connection‑oriented behavior, detailing the three‑way handshake for establishing a connection, the four‑step termination process, various state transitions, half‑open/half‑close scenarios, simultaneous open/close, initial sequence numbers, and the role of RST and TIME_WAIT.
This article walks through the complete journey of a web request—from entering a URL, checking browser, OS, router, and ISP DNS caches, performing DNS queries, resolving MAC addresses via ARP, establishing a TCP three‑way handshake, sending an HTTP request, to finally rendering the HTML page in the browser.
After a week-long series of experiments measuring TCP connections in various states—including ESTABLISH, client‑to‑server, server‑to‑client, and non‑ESTABLISH scenarios—the author quantifies per‑connection memory usage and shows how modern kernels reclaim buffers and reduce overhead, especially for TIME_WAIT.
This article explores three real‑world cases of TCP anomalies that affect database connectivity—ineffective RST packets, unexpected port exhaustion despite tcp_tw_reuse, and ghost connections caused by a full accept queue—explaining the underlying Linux kernel mechanics and offering practical mitigation strategies.
This article explains the fundamentals of the HyperText Transfer Protocol, covering the OSI model layers, TCP three‑way handshake, bandwidth versus latency, and the evolution from HTTP/0.9 through HTTP/1.0, 1.1, and HTTP/2, highlighting key improvements such as persistent connections, pipelining, chunked transfer, and server push.
Version v0.0.7 introduces a configurable keepalive timeout for the TCP RPC server, automatically closing idle client connections after a set period, reducing resource usage and preventing memory leaks while allowing the client to transparently reconnect when needed.
This tutorial walks through capturing and analyzing an HTTP request using Wireshark, detailing the environment setup, three‑way TCP handshake, key TCP header fields such as window scaling and SACK, the four‑step termination (including merged ACK/FIN), and the role of HTTP Keep‑Alive across different protocol versions.
This article explains why TCP suffers from sticky and unpacked packets, illustrates typical scenarios, outlines four common framing techniques, and shows how Netty's built‑in decoders can be used to reliably solve these issues in high‑performance network applications.
This article provides two practical approaches, complete with theory, kernel tuning, source code links, and detailed step‑by‑step commands, enabling readers to set up and verify one million concurrent TCP connections on Linux systems.
This article explains TCP concurrency theory, details two experimental approaches for reaching one million simultaneous connections using multi‑IP or multi‑port strategies, and provides step‑by‑step kernel tuning, source code, and validation commands for C, Java, and PHP implementations.
This step‑by‑step tutorial shows how to configure Linux kernel limits, set up multiple client IPs, and run PHP‑based server and client scripts to achieve and monitor over one million concurrent TCP connections on a single machine.
This guide walks through preparing a Linux server and client, adjusting kernel and user limits, configuring multiple IP addresses, and running PHP scripts to create and monitor up to one million concurrent TCP connections for performance testing.
This article explains the concept of TCP heartbeat, demonstrates how to use Netty's IdleStateHandler to implement client‑server heartbeat detection, and provides a complete Java example with reconnection logic, retry policies, and detailed code snippets for building a robust long‑connection service.
This article explains how to implement a TCP heartbeat mechanism using Netty's IdleStateHandler, details client and server handler implementations, and demonstrates a robust reconnection strategy with customizable retry policies, providing complete Java code examples for each component.
This article presents a seven‑day experiment measuring how much memory a TCP connection occupies in the kernel under various states such as ESTABLISH, data transfer, and TIME_WAIT, and summarizes the kernel's memory‑optimisation techniques for sockets.
This comprehensive guide explains TCP fundamentals—including the differences between TCP and UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, header fields, Fast Open, timestamps, retransmission timeout calculation, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear examples and diagrams for each concept.
This article explains how Linux manages TCP sockets at the kernel level, demonstrates how to adjust port ranges and file‑descriptor limits, and shows the key data structures and lookup functions that enable high‑concurrency TCP connections, providing practical guidance for scaling client connections.
This article traces the evolution of the HTTP protocol from its early days through HTTP/1.0, 1.1, SPDY, HTTP/2, and finally to HTTP/3, explaining how QUIC over UDP addresses TCP's latency and security limitations while also highlighting remaining challenges.
This article provides a comprehensive overview of TCP fundamentals, comparing it with UDP, detailing the three‑way handshake and four‑way termination, explaining SYN flood attacks, describing the TCP header fields, fast open, timestamps, retransmission timeout calculations, flow and congestion control mechanisms, as well as Nagle's algorithm, delayed ACKs, and keep‑alive behavior.
This article provides a comprehensive guide to TCP, covering its definition, connection-oriented nature, reliability, byte‑stream model, detailed packet header fields, three‑way handshake, four‑way termination, MTU/MSS concepts, Python simulation scripts, Wireshark capture techniques, common pitfalls, and practical networking programming steps.
This article explains how Linux manages TCP sockets at the kernel level, shows how to adjust system limits for massive concurrent connections, walks through key source code such as sock_common, tcp_v4_rcv, and inet_lookup, and provides practical tuning steps to achieve over a million simultaneous client connections.
A seven‑day series of experiments measures the memory footprint of TCP sockets in various states—including ESTABLISH, data transfer, and TIME_WAIT—showing how the Linux kernel optimizes socket memory usage and what factors influence the actual consumption.
The article presents a seven‑day series of experiments measuring how much memory a TCP connection occupies in various states—including ESTABLISH, data transfer, and TIME_WAIT—revealing kernel optimizations for socket buffer reclamation and overall memory overhead.
This guide shows how to increase the number of concurrent TCP connections on a Linux server by adjusting kernel parameters, expanding file descriptor limits, and understanding the underlying socket structures and lookup mechanisms that govern connection handling.
This article explores Linux’s TCP socket implementation, showing how to adjust system limits, dissecting key kernel structures like sock_common, and walking through the tcp_v4_rcv processing path and inet lookup functions, ultimately revealing methods to scale client connections beyond the traditional 65 535 port limit.
This guide explains how to optimize Linux kernel parameters and Nginx settings—such as file descriptor limits, TCP queue lengths, temporary ports, worker processes, KeepAlive, and log buffering—to significantly improve server performance and handle high traffic loads.
This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers, details the TCP four‑tuple theory, outlines Linux file‑descriptor restrictions, shows how to tune kernel buffers with sysctl, and shares a real‑world test achieving one million active connections.
This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.
This comprehensive guide explains TCP vs UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, header fields, timestamps, Fast Open, retransmission timeout calculations, flow control, congestion control, Nagle’s algorithm, delayed ACKs and keep‑alive mechanisms, providing essential knowledge for networking interviews and system design.
The article explains why a client can successfully write to a TCP socket after the server has closed its end, why the first write succeeds while the second fails, and how Linux kernel code and TCP state transitions cause this behavior.
This article explains how to adjust Linux kernel port ranges and file descriptor limits, explores the internal structures of TCP sockets, and walks through key kernel functions such as tcp_v4_rcv and __inet_lookup that locate sockets based on IP and port tuples, providing practical guidance for increasing TCP concurrency.
This article presents an illustrated comic that explains the basic principles of the TCP protocol, highlighting its connection-oriented reliable transmission, congestion and flow control mechanisms, while noting that some details are simplified and encouraging readers to consult formal RFCs and the TCP/IP Illustrated volume for deeper study.
This article reviews the development and core features of HTTP/2, explains why its TCP‑based design still suffers from head‑of‑line blocking and handshake latency, and argues that these inherent limitations make the transition to HTTP/3 over QUIC inevitable for modern web developers.
This article explains why TCP KeepAlive is needed, how it differs from HTTP Keep-Alive, and provides practical Linux kernel and Nginx configuration steps to prevent session timeouts in load‑balancing scenarios such as LVS and F5 devices.
This article explains the true limits of simultaneous TCP connections on a single Linux server, debunking common myths about the 65,535 port ceiling, detailing kernel and user‑level file‑descriptor restrictions, sysctl buffer settings, and a practical experiment achieving one million concurrent connections.
This article reviews the evolution of web communication protocols, detailing SPDY's pioneering features that influenced HTTP/2 and exploring QUIC's disruptive UDP‑based design, security mechanisms, multiplexing, connection migration, and other enhancements that reshape modern internet performance.
This article explains why TCP experiences sticky and half packets, analyzes the underlying causes such as buffer size mismatches and MTU limits, and presents practical solutions including short connections, fixed‑length framing, delimiter‑based framing, and length‑field framing, with their advantages and trade‑offs.
This article explains the differences between HTTP/1.1 and HTTP/1.0 keep‑alive, the TCP keepalive mechanism and its kernel parameters, how to configure them in applications, and how Nginx implements and manages keepalive for client and upstream connections with detailed code examples.
This article explains how to build a real‑time network chatroom in Java using TCP sockets, multithreading, and a ConcurrentHashMap to manage user connections, detailing command handling for listing users, group chat, private messages, exiting, and server shutdown, with full source code examples.
This comprehensive guide walks through TCP fundamentals—including its differences from UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, packet header fields, Fast Open, timestamps, RTT/RTO calculations, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear explanations and visual diagrams for each concept.
This article explains how Chrome uses multiple processes, the fundamentals of TCP/IP reliability, the HTTP request lifecycle, caching mechanisms, and the step‑by‑step flow from entering a URL to rendering a page, providing essential knowledge for front‑end interviews.
This article demystifies the true maximum number of concurrent TCP connections a single Linux server can sustain, explaining the theoretical limits of the TCP four‑tuple, the practical constraints imposed by file descriptor and memory settings, and walks through a real‑world experiment achieving one million connections.
This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers and TCP four‑tuple space, and shows how Linux file‑descriptor and socket buffer settings affect real‑world scalability, illustrated with a million‑connection experiment.
This article explains the role of the transport layer in the OSI model, compares TCP and UDP protocols, describes socket types and their APIs, clarifies port number usage, and details multiplexing, demultiplexing, and UDP packet structure with checksum calculation.
This article uses everyday analogies to compare UDP and TCP, outlines their core characteristics, typical use cases, and describes how to add TCP-like reliability features to UDP such as connection establishment, ordering, loss recovery, flow control, and congestion control.
This article traces the evolution of HTTP from its 1991 origins through HTTP/1.0, 1.1, HTTP/2, and finally HTTP/3, explaining how QUIC over UDP addresses TCP’s latency and security limitations while also highlighting remaining challenges.
This article provides a comprehensive introduction to the transport layer of computer networks, explaining the roles of TCP and UDP, socket APIs, port numbers, multiplexing, packet structures, connection management, three‑way handshake, four‑way termination, and congestion‑control mechanisms.
This tutorial provides a detailed introduction to Netty, covering its architecture, core concepts such as buffers, channels, selectors, reactor thread models, zero‑copy techniques, and includes practical TCP server/client code examples, helping readers understand and apply Netty for high‑performance Java network programming.
This article provides a comprehensive overview of the transport layer in the TCP/IP model, explaining the roles of TCP and UDP protocols, socket APIs, port numbers, multiplexing, and how data is encapsulated and transmitted between end systems.
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 uses a humorous long‑distance video‑chat scenario to illustrate why TCP requires a three‑way handshake for connection establishment and a four‑step termination, explaining each packet exchange, flag meanings, and related concepts such as half‑open connections and SYN‑flood attacks.
This article explains the TCP/IP layered model, differences between TCP and UDP, the three‑way handshake and four‑step termination, how HTTP builds on TCP, common HTTP status codes, message format, and the step‑by‑step process that occurs from entering a URL to loading a web page.
This article systematically explains the TCP/IP protocol suite, covering the four-layer model, data link, network, transport, and application aspects, and dives into key protocols such as IP, ARP, ICMP, DNS, as well as TCP connection management, flow control, and congestion control mechanisms.
This article examines a production incident where Dubbo services became congested, explains the underlying communication process with detailed code analysis, identifies key protocol and service parameters affecting performance, conducts experiments on connection count and TCP buffers, and offers practical recommendations to optimize Dubbo throughput.
This article provides a detailed introduction to the TCP/IP model, explaining each layer—from the physical and data link layers up to the application layer—along with key protocols such as IP, ARP, ICMP, TCP, UDP, DNS, and the mechanisms of connection establishment, termination, flow control, and congestion control.
During high‑concurrency traffic, servers can accumulate large numbers of TCP connections in the TIME_WAIT state, which can exhaust local ports and cause “address already in use” errors; this article explains the phenomenon, its underlying TCP mechanics, and practical configuration and kernel tweaks to mitigate the issue.
An imaginative tale reveals how two covert agents exploit the Linux kernel’s DelayedACKLost counter via /proc/net/netstat, using it to infer TCP sequence numbers and perform a side‑channel hijack, while illustrating the underlying delayed ACK mechanism, related kernel functions, and the security implications of this hidden metric.
Linux 5.10 brings a slew of network upgrades—including bundled BPF programs, support for over 255 IPv4 multicast interfaces, MPTCP refinements, Intel IGB XDP support, new Wi‑Fi driver chips, up to 20% performance gains for Mellanox NICs, and a BPF helper that boosts TCP throughput from 10 Gbps to 15 Gbps.
This article explains the TCP protocol’s header structure, the purpose of each field, how the three‑way handshake establishes a reliable connection, why three steps are needed, and the four‑step process used to gracefully close a TCP session, including verification with Wireshark.
This article explains the fundamental distinctions between GET and POST HTTP methods, covering how parameters are transmitted, caching behavior, URL length limits, security implications, and the underlying TCP packet flow, while debunking common myths and highlighting practical considerations for developers.
This guide explains how to tune Linux for high‑concurrency workloads by disabling unnecessary iptables, raising the per‑process file descriptor limit, modifying kernel TCP parameters via sysctl, and choosing appropriate I/O event mechanisms such as epoll or AIO.
This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.
This guide explains how to configure Linux for high‑concurrency workloads by increasing the maximum open files limit, adjusting kernel TCP parameters, and selecting appropriate I/O event mechanisms such as epoll or AIO.
This tutorial walks through creating a Netty HelloWorld server in IntelliJ IDEA using Gradle, adding the Netty dependency, implementing the server bootstrap, event loop groups, initializer and handler classes, and verifying the service with a curl request.
This article explains how to use Java's java.net.Socket and ServerSocket classes to create a server and client that exchange string messages, detailing the blocking behavior of accept() and read(), and providing complete code examples for sending and receiving data in both directions.
This article provides a systematic, hands‑on guide to DNS fundamentals—including dig queries, hierarchical lookups, Wireshark packet analysis, traditional DNS drawbacks, and HTTPDNS solutions—followed by a deep dive into WebSocket mechanics, handshake, frame structure, and security considerations, all illustrated with practical examples and code.
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 the TCP three‑way handshake, the four‑step connection termination process, and the eleven TCP state transitions, detailing the role of SYN, ACK, and FIN flags and illustrating each step with clear diagrams and concise descriptions.
This article explains TCP's core mechanisms, detailing the three‑way handshake and four‑way termination processes, the meaning of ACK, SYN, and FIN flags, and the eleven connection states with their roles in establishing and gracefully closing a reliable network connection.
This comprehensive guide explains TCP fundamentals—including its differences from UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN flood attacks, header fields, Fast Open, timestamps, retransmission timers, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear diagrams and practical insights for developers.
This article explains why a custom TCP protocol can be more efficient than HTTP, defines the protocol header and body format, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolver factories, server‑client bootstraps, and a Ping/Pong heartbeat mechanism—complete with runnable Java code and sample output.
This article explains why a custom protocol can be more efficient than HTTP for service-to-service communication, defines a simple binary protocol with header and body, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolvers, heartbeat handling, and client/server examples.
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.
Under high‑traffic conditions, servers can generate massive numbers of TCP TIME_WAIT sockets, consuming local ports and causing “address already in use” errors; this article explains the underlying causes, impact on services, and practical mitigation strategies such as keep‑alive headers and socket reuse.
This article details the TCP three‑way handshake, the four‑step connection termination process, and the full set of eleven TCP connection states, illustrating each step with clear explanations and diagrams for better network protocol comprehension.
This article explains the structure of Linux network I/O by detailing the OSI seven‑layer model, the role of each layer, MTU/PMTU concepts, IP fragmentation and reassembly, and key TCP mechanisms such as MSS, flow control, and congestion control, providing a comprehensive foundation for studying zero‑copy networking.
This article provides an in‑depth overview of TCP, explaining its core differences from UDP, the three‑way handshake and four‑way termination processes, half‑open queues and SYN‑Flood attacks, Fast Open, timestamp usage, retransmission timeout calculation, flow and congestion control mechanisms, as well as Nagle’s algorithm, delayed acknowledgments and TCP keep‑alive.
This article explains the 11 TCP connection states—including the three‑way handshake and four‑way termination—illustrated with packet captures, shows how to inspect them using netstat or ss, and discusses common Nginx TIME_WAIT problems and strategies for troubleshooting and performance tuning.
This article explains the MySQL client‑server handshake, details the sequence of packets exchanged during a TCP connection, and provides a complete Python implementation that builds a raw TCP socket to connect, authenticate, and communicate with a MySQL server without using a high‑level driver.
This guide walks you through building test environments, capturing packets with tcpdump, visualizing them in Wireshark, and dissecting TCP features such as three‑way handshake, retransmission timers, fast open, flow control, Nagle algorithm and delayed ACKs, while showing the exact Linux kernel parameters that control each behavior.
This article demonstrates how Swoole 4’s new coroutine kernel enables fully synchronous‑style PHP code to perform asynchronous I/O, file operations, database queries, and TCP/UDP networking within a single process, showcasing massive performance gains through practical code examples.
This article demonstrates how to build a high‑performance asynchronous TCP server using the Swoole extension in PHP, covering server creation, event callbacks for connection, data reception, and closure, as well as testing the server with telnet or netcat.
