This article explains the TCP three‑way handshake, how SYN Flood attacks exhaust server resources, and outlines Linux mitigation methods such as adjusting sysctl parameters, SYN Cache, and SYN Cookies, while discussing their trade‑offs and attacker strategies.
This article explains what DDoS attacks are, outlines their main categories—including high‑volume floods, TCP state‑exhaustion attacks, and application‑layer assaults—describes how each operates, and highlights why modern DDoS threats have shifted toward sophisticated application‑level techniques.
This article explains the complete journey of a web request—from DNS lookup and TCP handshake through HTTP exchange, server processing, and browser rendering—while highlighting optimization techniques and the roles of front‑end and back‑end engineers.
This article explains the TCP three‑way handshake, four‑way termination, and related state transitions, illustrates uncommon scenarios such as simultaneous open and close, discusses half‑open connections, fd‑leak effects, and presents Linux‑based experiments with client.go and server.go code samples.
This article provides a comprehensive introduction to TCP, covering its header structure, optional fields, the role of MSS and TSO, mechanisms for reliability and retransmission, as well as detailed explanations of flow control, sliding windows, and congestion control algorithms.
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 guide explains how to set up NAT server and NAT outbound on a Huawei router so that internal users can access a server via the router's WAN IP on port 80 and external users can reach the same server using port 8089, including required ACL and interface configurations.
This comprehensive guide walks through HAProxy's version landscape, connection and closing modes, load‑balancing algorithms, persistence, content routing, header rewriting, multiple configuration examples—including dynamic and multi‑process setups—and practical debugging tips, supplemented by a live Q&A session.
This article provides a comprehensive overview of HTTP, TCP, UDP, and socket communication, explaining protocol layers, request/response structures, key headers, and the differences between GET and POST methods for web development.
This guide explains how to raise Linux user‑process file descriptor limits, adjust kernel TCP parameters, and use efficient I/O mechanisms such as epoll or AIO to support thousands of simultaneous TCP connections for high‑concurrency network programs.
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 the structure and fields of IP packets, including version, header length, TOS, total length, ID, flags, fragment offset, TTL, protocol, checksum, source and destination addresses, as well as the formats and key functions of TCP and UDP headers, highlighting their differences.
This guide introduces Python’s socket module, explains socket families and types, details essential server and client functions, walks through step‑by‑step TCP connection creation, and provides complete server and client code examples for practical network programming.
This article outlines Baidu Maps' mobile network optimization strategies, covering the overall architecture, common wireless issues such as DNS failures and hijacking, and practical solutions like HTTP‑DNS, custom TCP/UDP HTTP, data compression, unified domain entry, and deployment tactics that significantly improve user search latency and engagement.
This article explores four high‑performance TCP server models in .NET/C#—Asynchronous Programming Model (APM), Task‑based Asynchronous Pattern (TAP), SocketAsyncEventArgs (SAEA), and Registered I/O (RIO)—detailing their accept and read loops, implementation nuances, pooling strategies, and sample code, while highlighting performance considerations and real‑world usage.
This article details the design and implementation of 58’s real‑time messaging platform, covering its business background, overall architecture, protocol design for extensibility and debugging, and solutions for fast TCP reconnection to ensure stable, high‑throughput delivery for intra‑city freight services.
With broadband speeds soaring, UDP’s simplicity and low latency now outperform TCP in web browsing, streaming, gaming, and IoT, as real‑world tests from Akamai and Google show dramatically lower packet loss, faster connections, and reduced buffering, signaling a shift toward UDP‑centric networking.
Ctrip's wireless development team shares a comprehensive overview of their app's network architecture, common performance pitfalls such as DNS and TCP issues, and a series of practical optimizations—including DNS caching, quality detection, priority handling, retransmission, payload reduction, and protocol upgrades—that dramatically improved service success rates and reduced latency.
Ctrip's wireless development director shares a comprehensive overview of the app's network architecture, common performance pitfalls, and six concrete optimization techniques that boosted service success rates above 99% and cut latency by up to 200 ms across diverse network conditions.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, and compares long‑lasting persistent connections with short‑lived ones, covering their handshakes, advantages, disadvantages, and appropriate usage scenarios.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, compares short and long connections in HTTP/1.0 and HTTP/1.1, and discusses the advantages, disadvantages, and appropriate use cases for each connection type.
This article explains how to add Protocol Buffer communication to a PHP web system, covering library setup, proto file adjustments, code generation, binary TCP handling with pack/unpack, and the switch from read_line to fread for reliable socket reads.
This article discusses whether PC1 can successfully access PC2’s web service when outbound traffic passes through a NAT router but the return packets bypass the router via a core switch, examining potential TCP connection issues caused by asymmetric routing and providing relevant ACL and NAT configuration examples.
This article details a real‑world Nginx performance tuning case where long‑running client requests caused timeouts, describing how adjusting keepalive settings, TCP reuse parameters, and upstream proxy timeouts eliminated the delays and stabilized the service for millions of calls.
This article details the analysis and redesign of Line, WhatsApp, and WeChat heartbeat mechanisms, presenting a simplified adaptive heartbeat algorithm, its testing methodology, comparative push strategies, GCM characteristics, and practical improvement suggestions to reduce power consumption, network load, and latency.
This guide explains how to increase Linux's per-process file descriptor limits, adjust kernel TCP parameters, and adopt high-performance I/O models such as epoll or AIO to support tens of thousands of concurrent TCP connections.
HAProxy is an open‑source, high‑performance load‑balancing software that operates at both layer 4 (TCP) and layer 7 (HTTP), offering strong reliability, massive concurrency handling, flexible algorithms, and powerful monitoring, making it ideal for large‑scale web and database workloads.
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.
The article details Ctrip's mobile app network service architecture, explaining native TCP and hybrid HTTP communication, describing common performance issues such as DNS, TCP, payload size, and presents six optimization practices—including DNS caching, quality detection, priority handling, retransmission, payload reduction, and overseas network improvements—to achieve higher success rates and lower latency.
This article explains the Linux TCP connection‑establishment, packet‑receive, and packet‑send paths, categorizes related kernel parameters such as backlog, SYN‑cookie, ring buffers, and socket buffers, and provides practical commands and guidelines for optimizing network performance on servers.
The article details Ctrip's mobile app network architecture, common performance bottlenecks such as DNS, TCP, and payload issues, and presents six practical optimization techniques—including DNS caching, network‑quality detection, service prioritization, retry mechanisms, payload compression, and overseas CDN improvements—that collectively reduced latency by 150‑200 ms and raised service success rates above 99 %.
This article analyzes common push‑service questions, presents a real‑world IoT case of memory leakage, and outlines key design points—including kernel limits, CLOSE_WAIT handling, heartbeat configuration, buffer management, memory pooling, logging pitfalls, TCP tuning, and JVM settings—to build a scalable, stable Netty‑based push server for millions of concurrent connections.
This article explains the TCP three-way handshake and four-way termination processes, detailing each packet exchange, state transition, and the reasons why these mechanisms are essential for reliable network communication.
This article explains the TCP KeepAlive mechanism, why load balancers like LVS and F5 drop idle connections after 90 seconds, how to configure Linux kernel and socket options, and the correct way to enable TCP KeepAlive in Nginx to prevent premature disconnects.
This article demystifies TCP optimization by explaining flow control, slow start, congestion avoidance, and practical methods to tune the receive and congestion windows (rwnd and cwnd) on Linux systems for better network performance.
This article explains TCP fundamentals—including three‑way handshakes, sliding windows, and four‑way termination—then details how the RST flag works and how attackers can forge packets using source ports and sequence numbers to execute powerful RST denial‑of‑service attacks.
