This guide explains how to install iPerf on Linux, macOS, and Windows, shows basic server‑client usage, details advanced command‑line options, and provides practical examples for measuring TCP and UDP bandwidth performance.
This article contrasts the fast, connection‑less nature of UDP with the reliable, connection‑oriented TCP, outlines their key characteristics and handshake processes, and then introduces a comprehensive 570‑command Linux cheat‑sheet for administrators and developers.
This article explains the 11 TCP connection states, the three‑way handshake, the distinction between half‑open and full‑open queues, common backlog‑related problems, diagnostic commands, and key Linux kernel sysctl parameters for tuning TCP performance.
The article explains the TCP three‑way handshake, why the third ACK is essential, how servers react when it is missing, the role of timeout retransmission and RTO calculation, the impact of SYN‑Flood attacks, and how these concepts inspire backend design patterns.
This article provides an extensive overview of C++ network programming concepts frequently asked in interviews, covering sockets, TCP/UDP differences, I/O multiplexing models, handshake mechanisms, packet framing issues, concurrency strategies, code examples for servers and clients, and performance optimization techniques.
This article examines the causes and consequences of TCP half‑open and full‑connection queue saturation, explains how the Linux backlog mechanism works, and offers practical solutions for handling listen overloads, drawing on a range of technical references and real‑world troubleshooting experiences.
This article provides a comprehensive overview of the OSI model, explaining the purpose of each of its seven layers, their responsibilities, typical devices and protocols involved, and how data moves from the physical medium up to the application level.
This article explains the eleven TCP connection states, details the three‑way handshake and four‑way termination processes, compares half‑ and full‑connection queues, and provides Linux kernel parameters and commands for tuning server backlog and handling common TCP issues.
This guide explains the Linux kernel TCP parameters located under /proc/sys/net/ipv4/ and /proc/sys/net/core/, shows how to tune them with sysctl, and provides practical examples and recommended values for improving network performance and security.
This comprehensive guide walks through Go’s net package, detailing how Listener functions create servers, how Dial functions initiate client connections, the nuances of network and address formats, and the behavior of various Conn types such as TCPConn, UDPConn, IPConn, and RawConn, complete with code examples and best‑practice tips.
This article provides a comprehensive overview of Linux socket programming, covering socket definitions, classifications such as stream, datagram, and raw sockets, connection-oriented versus connectionless communication, IP/port/MAC addressing, byte order considerations, and practical C API examples for creating and using sockets.
This article debunks the common myth that a server can only handle 65,536 TCP connections by exploring the theoretical four‑tuple limits, practical constraints like file descriptors, port ranges, and memory/CPU usage, and explains how the true upper bound is far larger.
This article provides a comprehensive guide to TCP connection states, common Linux commands for monitoring them, detailed explanations of each state transition, three‑way handshake, four‑way termination, flag meanings, keep‑alive mechanisms, and practical sysctl tuning to troubleshoot network issues.
The article analyzes a mysterious production stall caused by a TCP communication bug where the D4 and D5 stages are merged, leading to a mis‑aligned length field that makes the server read an incorrect payload size, and presents two concrete fixes.
This article provides a comprehensive guide to TCP connection states, Linux commands for monitoring them, the three‑way handshake, four‑way termination, flag meanings, common pitfalls like SYN floods, and practical keep‑alive and sysctl tuning techniques for reliable network troubleshooting.
This article explains why ping and TCP may travel different network paths, covering router behavior, routing tables, OSPF, Dijkstra's algorithm, ECMP, five‑tuple hashing, packet reordering, and practical troubleshooting techniques such as traceroute and nc.
This article explains how to expose a lightweight, dependency‑free client API for a Rust‑based database by defining a simple TCP‑based JSON serialization protocol, detailing non‑functional and functional requirements, the Message and Command structures, and providing a concrete Ping command implementation in Rust.
This article explains how TCP, the reliable transport‑layer protocol, differs from HTTP, the application‑layer web protocol in terms of purpose, connection handling, and data formatting, helping readers understand why TCP underpins HTTP while each serves distinct roles on the Internet.
This article explains the purpose of TCP RST packets, how they appear during connection establishment, data transfer, firewall enforcement, and teardown, and provides practical techniques for distinguishing legitimate resets from spoofed or policy‑driven resets to improve network troubleshooting and security.
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.
A client sends 1 KB TCP packets every second with a 4 KB SO_SNDBUF while the server never calls recv(), yet the observed Send‑Q grows to 14 480 bytes, revealing how the Linux kernel doubles the buffer size, uses sk_wmem_queued, and expands write queues via GSO and memory scheduling.
The article details a mysterious production stall at 70% caused by a TCP packet length field misalignment when the configuration name is "rabbit‑TD", explains the step‑by‑step investigation using server logs and packet captures, identifies the root cause of the merged D4/D5 packets, and proposes two concrete fixes to correct the length handling.
This article explains TCP connection states, the three-way handshake and four-way termination processes, provides essential Linux commands for monitoring connections, and offers practical tips for diagnosing network issues, handling SYN floods, TIME_WAIT problems, and implementing keepalive mechanisms to maintain reliable communication.
A Linux client that sets SO_SNDBUF to 4096 bytes and sends 1 KB packets to a non‑receiving server sees the TCP Send‑Q grow to 14480 bytes, revealing how the kernel doubles the buffer size, uses sk_wmem_queued, and expands memory via GSO‑driven size goals.
This article explains what TCP RST packets are, why they appear during connection establishment, data transfer, and termination, and how to diagnose server‑side, client‑side, and firewall‑induced resets by examining sequence diagrams, common error conditions, and TTL differences.
The article explains why network protocols use layered design, details TCP's reliability and congestion‑control mechanisms, outlines HTTP status‑code categories, reviews MySQL lock scopes from global to row‑level, provides a C++ breadth‑first binary‑tree traversal example, and describes a three‑step weighing puzzle to find an odd ball.
This article explains how TCP ensures reliable data transfer through connection management, sequence and acknowledgment mechanisms, retransmission strategies, flow control, and congestion control, and includes C++ example code illustrating a simple client‑server file transfer implementation.
This article dissects the Linux kernel's TCP connection workflow, explaining how the three‑way handshake prevents stale SYN packets, and walks through the socket(), bind(), listen() and connect() system calls with detailed code analysis of the underlying kernel functions and data structures.
This article explains what TCP RST packets are, why they appear during connection establishment, data transfer, and termination, and how to analyze their causes—including server refusals, client errors, firewall policies, retransmission limits, idle timeouts, and bypass blocking—using sequence diagrams and practical diagnostics.
This article explains how TCP and UDP handle packet fragmentation, the differences between MSS and MTU, why data slicing is needed, how the Nagle algorithm works, the causes of sticky packet problems, and practical methods to avoid or resolve them in network programming.
This article explains what TCP sticky packets are, why they occur due to rapid sending, slow reading, or buffer limits, and presents practical solutions such as fixed‑length framing, delimiters, padding, and the Nagle algorithm to ensure reliable data parsing.
TCP RST packets, used to abruptly terminate or reject connections, appear at various stages—handshake, data transfer, and teardown—and can stem from server port closures, connection limits, malformed SYNs, firewall policies, timeouts, or middlebox interventions, with each scenario identifiable through detailed packet‑level analysis.
This guide explains how to implement a custom TCP protocol in PHP using Workerman for Unity3D multiplayer games, covering the sticky‑packet problem, protocol interface methods, two concrete protocol examples, and step‑by‑step testing of packet framing and splitting.
This tutorial series for newcomers explains TCP timeout retransmission, window management, and congestion control, combining theory with practical experiments using tcpdump, netstat, iptables, and Scapy, and demonstrates how Linux kernel parameters affect retransmission behavior and performance.
This article explains the Linux kernel limits that determine how many files and TCP connections a server can open, shows how to tune fs.file-max, soft/hard nofile, and fs.nr_open, estimates realistic connection counts based on memory, and provides practical configuration examples for large‑scale services.
This article explains the fundamental differences between UDP and TCP, details the TCP header fields, walks through the three‑way handshake and its necessity, describes the four‑way termination process, and illustrates the complete TCP state machine with diagrams and practical examples.
This guide explains how to prepare source and target servers, install iPerf, run it in server and client modes on Windows (or Linux), and use specific commands to measure TCP bandwidth, UDP jitter, packet loss, and network latency, including required firewall and security‑group settings.
This article explains why a TCP connection's Send‑Q can exceed the user‑set SO_SNDBUF value, detailing the kernel's double‑buffer trick, sk_wmem_queued accounting, tcp_sendmsg behavior, GSO influence, and possible ways to limit the buffer growth.
This article walks through a production‑level OceanBase connection‑timeout incident, detailing how to examine OBProxy logs, capture and analyze network packets with tcpdump and Wireshark, identify a blocked random port, and apply kernel‑parameter fixes to prevent the issue.
A Linux client sets SO_SNDBUF to 4096 bytes, sends 1 KB packets while the server never reads, yet the TCP Send‑Q grows to 14480 bytes because the kernel doubles the buffer size, adds overhead, and expands memory via GSO and sk_wmem scheduling.
This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.
This article explains the complete journey of a web request—from IP addressing, DNS resolution, and CDN acceleration, through TCP stream handling and message framing, to CGI/FastCGI execution, server model choices, and the evolution of data-layer architectures for scalable applications.
The article walks through every stage of a web request—from IPv4 addressing, NAT, and DNS resolution through CDN proximity and TCP stream handling, to HTTP framing, CGI versus FastCGI processing, stateless versus stateful server models, and finally database scaling techniques such as sharding and Redis caching.
This guide walks you through preparing the environment, installing iPerf on Windows or Linux servers, running it in server and client modes, testing TCP and UDP performance, measuring latency with ping, and checking all available options to ensure reliable network bandwidth and latency measurements.
The article walks through a real‑world case where an app’s content fails to load due to MTU/MSS mismatches, explains how packet‑capture analysis reveals the problem, demonstrates ping‑based MTU testing, and shows how oversized API parameters triggered the failure.
This article explains how TCP connections are identified, the theoretical maximum numbers for client and server sides, and why real‑world limits are governed by system resources, port reuse, and server architecture rather than the 65,535 port ceiling.
This article walks through a real‑world case where an app’s content loading fails due to MTU/MSS mismatches, explains how packet captures reveal retransmissions and missing ACKs, demonstrates ping‑based MTU probing, and shows how oversized request parameters in a new version caused the issue.
This article compiles seven hands‑on Linux performance‑optimization practices, covering key factors such as CPU, memory, disk I/O, network, swap usage, and TCP tuning, and provides concrete commands and step‑by‑step troubleshooting methods for system administrators and DevOps engineers.
The intermittent timeout between cloud host A and game server B was traced to the server’s net.ipv4.tcp_tw_recycle setting, which dropped SYN packets with non‑monotonic timestamps after NAT translation, and disabling this kernel parameter restored normal connectivity.
This article explains the TCP packet fragmentation and aggregation problems, introduces Netty's various decoder mechanisms such as FixedLengthFrameDecoder, LineBasedFrameDecoder, DelimiterBasedFrameDecoder, LengthFieldPrepender, and LengthFieldBasedFrameDecoder, and provides detailed configuration examples and code snippets for implementing robust TCP protocols.
To handle high‑traffic web workloads, the default Linux kernel settings must be adjusted; this guide explains the key sysctl parameters—such as file‑max, tcp_tw_reuse, tcp_keepalive_time, and buffer sizes—and how to apply them for optimal Nginx concurrency.
This article explains how QUIC, a UDP‑based transport protocol developed by Google, overcomes TCP's limitations such as handshake latency and head‑of‑line blocking, offering lower latency, multiplexing, built‑in TLS 1.3 security, and why it powers the emerging HTTP/3 standard.
This article provides a comprehensive overview of the OSI model, detailing each of its seven layers—from the physical and data link layers up to the application layer—explaining their functions, protocols, and how they interact to enable network communication.
This comprehensive guide covers TCP fundamentals—including differences from UDP, the three‑way and four‑way handshakes, half‑open queues and SYN flood attacks, header fields, Fast Open, timestamps, RTO calculation, flow and congestion control, Nagle algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear explanations and practical examples for engineers.
Linux system performance depends on CPU, memory, disk I/O, network, kernel parameters, and hardware, and troubleshooting requires comprehensive checks using tools like top, vmstat, iostat, netstat, perf, and sysctl, with step‑by‑step guidance for identifying bottlenecks, optimizing resources, and tuning TCP settings.
A Linux client sets SO_SNDBUF to 4096 bytes and sends 1 KB packets while the server never receives them, yet the TCP Send‑Q grows to 14480 bytes, prompting an in‑depth analysis of kernel buffer accounting, double‑sized send buffers, and tcp_sendmsg behavior.
This guide explains the key factors that affect Linux system performance, provides step‑by‑step troubleshooting methods for CPU, memory, disk I/O and network issues, shows how to identify top resource‑hungry processes, clarifies memory reporting differences, discusses swap usage scenarios, and offers concrete TCP tuning parameters for production environments.
This article explains TCP packet fragmentation and aggregation (sticky/unsticky packets), demonstrates the phenomena with examples, and provides detailed solutions using Netty's built‑in decoders such as FixedLengthFrameDecoder, LineBasedFrameDecoder, DelimiterBasedFrameDecoder, and LengthFieldBasedFrameDecoder, including code samples and configuration tips.
This article explains why the TCP Send‑Q can grow beyond the user‑set SO_SNDBUF value by examining the kernel’s double‑buffer accounting, sk_wmem_queued handling, and the interaction of tcp_sendmsg with GSO, supported by code excerpts and diagrams.
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 the fundamentals of TCP, why raw TCP communication faces issues like message boundary ambiguity, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their use cases, performance, and evolution to help developers choose the right protocol for their systems.
This article uses a playful story of a Linux process to explain the real limits on TCP connections, covering the configurable port range, file descriptor caps, thread model constraints, memory usage, and CPU saturation, and shows how to adjust these limits on a Linux server.
This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.
The article investigates why MySQL batch jobs experience aborted connections, tracing the issue to TCP buffer overflow on the client side, excessive ACK traffic, and the default net_write_timeout of 60 seconds, and proposes kernel tweaks and query optimizations to resolve the problem.
This article explains TCP basics, why raw TCP communication has boundary issues, how custom protocols like HTTP and RPC are built on TCP, and compares their purposes, performance, and usage scenarios in modern software architecture.
This article explains what ports are, why they are essential for web and other services, how default ports work, the role of ports in inter‑process communication, and how they relate to concepts like naming services and inversion of control.
This comprehensive guide reviews essential network and operating system concepts for technical interviews, covering TCP three‑way handshake, four‑way termination, OSI/TCP‑IP models, common protocols, socket communication, process vs thread, IPC mechanisms, memory management, page‑replacement algorithms, and HTTP/HTTPS differences.
This article explains step‑by‑step what occurs when a user types a URL and presses Enter, covering URL parsing, DNS resolution, TCP three‑way handshake and four‑way termination, HTTP request/response formation, and the browser’s rendering process, providing interview‑ready insights into web networking fundamentals.
This article explains the core characteristics of TCP and UDP, compares their reliability and connection models, clarifies the concept and range of port numbers, and demonstrates that both protocols can share the same port without conflict, illustrated with real‑world examples such as DNS.
This article explores the fundamentals of TCP communication, explains why raw TCP lacks message boundaries, and compares HTTP and RPC protocols—covering their histories, use cases, service discovery, connection handling, serialization, and performance trade‑offs—to answer why both coexist in modern software architectures.
This article consolidates community‑sourced Linux performance optimization practices, covering key factors that affect system speed, rapid troubleshooting steps for CPU, memory, disk and network issues, load‑analysis methods, top‑resource identification commands, memory‑stat nuances, swap usage scenarios, and detailed TCP tuning recommendations.
This article provides a comprehensive overview of the Transmission Control Protocol (TCP), covering its connection‑oriented design, reliability mechanisms, three‑way handshake, four‑step termination, packet structure, flow and congestion control, and practical C++ socket examples for establishing, sending, receiving, and closing connections.
Ports act as an essential indirection layer that maps network requests to specific processes, enabling protocols like HTTP and HTTPS to function, while default ports simplify user interaction; this article explains common ports, default values, the role of IPC, naming services, and how ports embody inversion of control principles.
This article explains the fundamentals of TCP RST packets, distinguishes active and passive resets, outlines common kernel scenarios that generate them, and provides practical debugging methods using tcpdump, bpftrace, and source‑code analysis to resolve real‑world network incidents.
This article explains what ports are, why default ports like 80 and 443 exist, how ports enable inter‑process communication, act as a naming service and an indirection layer, and why they are essential for both web and non‑web services.
This article explains Go’s socket programming model, covering the classic five‑step workflow, the versatile net.Dial function, and practical code examples for ICMP, TCP, and HTTP client operations, helping developers build networked applications efficiently.
This article explains the role of protocol numbers in IP headers, introduces common network protocols such as ICMP, TCP, UDP, GRE, and VRRP with their assigned numbers and typical use cases, and shows how to locate the official list via IANA for troubleshooting and configuration.
This article explains the TCP socket programming interface, detailing server and client API functions, their purposes, the three‑way handshake, state transitions, data transmission, segmentation, sticky‑packet issues, and the four‑way termination process, providing code examples and diagrams for clear understanding.
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.
TCP (Transmission Control Protocol) is a connection-oriented, reliable, byte-stream transport layer protocol that ensures ordered, error-free data delivery through mechanisms such as three-way handshake, four-way termination, flow control, and congestion control, making it essential for web browsing, email, and online gaming.
The article analyzes how TCP's three‑way handshake, slow‑start, and initial congestion window can introduce extra round‑trip times, causing service latency to far exceed network RTT, and shows practical packet captures, Linux defaults, and mitigation techniques.
This guide explains why SSH connections may close due to TCP timeouts, describes the relevant kernel parameters, and provides step‑by‑step client and server configuration instructions for Linux and Windows to keep SSH sessions active without interruption.
TCP (Transmission Control Protocol) is a core Internet protocol that ensures reliable data transmission through mechanisms such as three‑way handshake, flow and congestion control, segmentation and reassembly, and error detection, while also facing challenges like latency, packet loss, and emerging real‑time application demands.
A single server‑side process can theoretically handle up to 2^48 (≈2.8×10^14) TCP connections, but Linux file‑descriptor limits and memory consumption (about 3.44 KB per connection) restrict real‑world capacity to a few million connections per 8 GB machine, while a whole server’s total is bounded by the same resource constraints despite the much larger theoretical maximum.
The article analyzes how TCP's congestion control and slow‑start mechanisms introduce extra round‑trip times, causing service latency to far exceed network RTT, and explains how TCP connection setup, cwnd limits, and long‑lived connections affect overall response times.
This article provides a comprehensive overview of core network protocol structures—including TCP, UDP, IPv4/IPv6, IPSec, Ethernet, 802.1Q, 802.11, SSL, RTP, and OpenFlow—detailing their header fields, functions, and security mechanisms to help readers grasp essential networking concepts.
This article presents a complete Netty TCP client demo that uses a local BlockingQueue to simulate a message broker, applies Redis distributed locks to prevent duplicate connections, integrates Spring Boot 2.2.0, and provides detailed code, workflow, and testing instructions for developers.
This article compiles common technical interview questions for bank software positions, covering Java fundamentals, MySQL storage engines and indexes, thread‑pool parameters, HTTP GET/POST differences, TCP vs UDP characteristics, session and cookie handling, Redis data types, and C++ memory management, providing concise explanations and examples for each topic.
This article compiles essential backend interview questions and answers covering MySQL storage engines and indexes, Redis persistence modes, Java collection frameworks and HashMap internals, thread‑safe ConcurrentHashMap implementations, as well as HTTP message structure and TCP reliability mechanisms, providing a thorough review for candidates preparing for backend positions.
The article examines the scalability limitations of the Linux kernel TCP/IP stack, comparing its packet‑processing and connection‑setup performance with user‑space stacks such as mTCP and F‑Stack, explains how hash‑table locking and spin‑lock contention cause poor CPS scaling, and argues why user‑space implementations often achieve higher throughput despite their own trade‑offs.
This article investigates a rare TCP four‑handshake disorder where out‑of‑order FIN and ACK packets cause a server to wait for a timeout before closing, detailing packet captures, kernel code analysis, eBPF monitoring, and the discovery that the shutdown() call versus close() triggers the issue.
This article explains how Linux kernel parameters, memory size, and file descriptor limits determine the maximum number of TCP connections a server or client can handle, provides configuration examples for increasing those limits, and discusses practical considerations such as port ranges and connection overhead.
This article explains the fundamentals of sockets as a network communication abstraction, covering process communication, TCP/UDP protocols, socket descriptors, key system calls, the TCP three‑way handshake and four‑way termination, Linux kernel basics, and provides complete C examples for a server and client.
This article presents a complete Netty TCP client demo built with Spring Boot, detailing the project architecture, module layout, business flow, key code implementations—including a local BlockingQueue, message processing with Redis locks, client initialization, handler logic, and testing endpoints—providing a practical reference for backend developers.
This article presents a complete Netty TCP long‑connection demo built with Spring Boot 2.2.0 and Redis, explains the project architecture, module layout, business flow using a local BlockingQueue instead of RocketMQ, and provides detailed source code for the queue holder, processing logic, client implementation, handler, and test controllers.
This article provides a comprehensive overview of computer networking fundamentals, including C/S and B/S architectures, OSI layers, TCP/UDP protocols, socket programming, code examples, and the concepts of synchronous, asynchronous, blocking, and non‑blocking I/O in Linux.
This article examines the technical reasons behind TCP's design as a stream-oriented transport protocol, contrasting it with a packet-oriented approach, and explores the implications for lower and upper layers, packet sizing, application-layer framing, and alternative solutions such as UDP, QUIC, and custom protocols.
TCP and UDP are core transport-layer protocols of the Internet; this article explains their basic concepts, characteristics, reliability mechanisms, flow and congestion control, three-way handshake and four-way termination for TCP, and highlights the strengths and weaknesses of each protocol for various applications.
This article explains the TCP/IP protocol suite, detailing its four layers—link, network, transport, and application—along with key protocols such as IP, TCP, UDP, ARP, ICMP, DNS, and the mechanisms of packet encapsulation, routing, flow and congestion control, and connection management.
An in‑depth guide walks through TCP basics, why raw TCP lacks message boundaries, how HTTP and RPC build on TCP, and compares their service discovery, connection handling, and serialization, revealing why both protocols coexist in modern client‑server architectures.
