This article explains why the common getRemoteAddr() call often returns proxy addresses, details the underlying IP header propagation, and provides a production‑grade utility class, Spring Boot configuration, advanced interception, testing, and best‑practice guidelines for reliably obtaining the true client IP.
An IRC user in 2005 threatened to hack the admin, who cheekily responded with the loopback address 127.0.0.1; the attacker’s attempts repeatedly timed out, illustrating that packets sent to 127.0.0.1 never leave the host, a classic networking lesson that turned into an internet meme.
Entering the numeric URL https://16843009 in a browser redirects to Cloudflare’s DNS page because the integer 16843009 corresponds to the IPv4 address 1.1.1.1, illustrating how IPv4 addresses are 32‑bit unsigned integers and can be expressed in decimal, hexadecimal, octal, and other notations.
This article explains how Java developers can retrieve a client’s IP address from an HttpServletRequest, handle proxy headers, and use the ip2region library (via Maven) to map the IP to its province and city, including code snippets and configuration details.
Although many developers store IPv4 addresses in MySQL using VARCHAR(15), the optimal approach is to store them as a 32‑bit unsigned integer, which saves space, speeds up indexing, and can be easily converted with MySQL's inet_aton and inet_ntoa functions.
This article walks through the complete DHCP process—from a device’s initial broadcast for an IP address, through server offers, request, and acknowledgment—while also covering static versus dynamic IP configuration, lease management, and common troubleshooting scenarios such as missing addresses and IP conflicts.
When a device connects to a network, it initiates a DHCP discovery process, receives an IP address offer, confirms the assignment, and eventually leases the address, with static and dynamic options, subnet masks, gateways, DNS settings, renewal cycles, and conflict resolution all playing crucial roles.
This article explains the role of DNS as the hidden navigator that maps human‑readable domain names to IP addresses, details the four‑layer caching hierarchy, walks through recursive and iterative query flows, outlines common DNS failures, and offers practical troubleshooting and performance‑boosting tips.
This article walks through how a device obtains an IP address via DHCP, covering the broadcast discovery, server offer, client request, and acknowledgment phases, the differences between static and dynamic addressing, lease management, common conflicts, and practical troubleshooting steps.
This article explains how Google’s public DNS address 8.8.8.8 rose from a simple, memorable IP to a globally trusted service by offering speed, stability, security, and universal accessibility, while also covering the basics of DNS, its evolution, and whether it’s still needed today.
This article explains the origins, technical classification, and evolution of the IP address 1.1.1.1 from an unassigned block to Cloudflare's fast, privacy‑focused public DNS, covering its network segment, Anycast deployment, encrypted DNS support, and comparison with other DNS services.
This article explains why backend services often see proxy IPs instead of the true client address in modern cloud‑native architectures, and provides a detailed walkthrough of configuring Envoy—including X‑Forwarded‑For handling, code snippets, testing, and security recommendations—to ensure the original client IP is correctly propagated.
This article reveals that the familiar 127.0.0.1 address is just one of over 16 million loopback IPs, explains what a loopback interface is, shows practical uses such as parallel testing, service isolation, DNS simulation, and warns about security pitfalls when misusing the 127.x.x.x range.
The article explains that storing IPv4 addresses as a 32‑bit UNSIGNED INT in MySQL reduces storage and index size, speeds up range queries, and provides built‑in conversion functions, while also noting readability drawbacks and offering Java conversion examples.
This guide explains how to view network interfaces, edit the ifcfg files, enable IPv6 autoconfiguration, set static IPv4/IPv6 addresses, assign temporary addresses, restart the network service on CentOS 6/7, and verify connectivity with ping commands.
This article explains what IP addresses are, outlines IPv4 address classes and private ranges, describes network, broadcast, and host addresses, and provides step‑by‑step VLSM subnetting calculations with multiple practical examples for various network scenarios.
This article explains the definitions, types, and functions of IP addresses and domain names, describes how DNS resolves domain names to IPs, and outlines best practices for using each in API automation testing to improve maintainability, scalability, and reliability.
This article explains the nature of 127.0.0.1, localhost and 0.0.0.0, why pinging the loopback address works without a network connection, and how the operating system routes such traffic through a virtual network interface.
This guide explains how to quickly retrieve the IP address of a running Docker container using simple commands such as `docker ps`, `docker inspect`, and a formatted inspect query, with step‑by‑step instructions and example output for easy debugging and network configuration.
This guide walks through a real‑world operations scenario, showing how to write and run a Bash script that uses the sort command with numeric and field options to correctly order a list of IP addresses for easier log analysis and network troubleshooting.
A Chinese procurement announcement listed the localhost IP 127.0.0.1 in five bidders' documents, sparking online debate and technical analysis that traced the issue to a bug in the official electronic tender software, which can be reproduced by disabling IPv4.
This article explains why a newly plugged‑in computer can instantly obtain an IP address, detailing DHCP’s four‑stage process, the role of UDP broadcasting, packet‑capture commands, unicast optimizations, lease reuse, possible IP conflicts, and the gratuitous ARP messages that follow an ACK.
This guide explains how to install the s1lentium/iptools PHP library and use its classes to parse, convert, and operate on IPv4 and IPv6 addresses, networks, and ranges, including examples of CIDR calculations, reverse DNS, and host enumeration.
This article explains what localhost and the loopback address 127.0.0.1 are, how they are resolved without DNS, their role in web development, the domain name hierarchy, private IP ranges, virtual hosting, and an introduction to IPv6 addressing.
The article explains how IP addresses and DNS work, why a centralized DNS design is problematic, describes the distributed three‑level DNS architecture, introduces DNS security with digital signatures, and details the rigorous key‑ceremony process that protects the ICANN root key.
This article explains what an IP address is, how IPv4 and IPv6 differ, why the 192.168.x.x range dominates home networks, the role of CIDR and private versus public addresses, and practical ways to view your own internal and external IP using common command‑line tools.
The article explains how major internet platforms now display users' IP location without consent, outlines the technical background of IP addresses, discusses related privacy and legal concerns, and offers practical steps to safeguard personal information online.
Since 2021 Chinese platforms have begun displaying users' IP location down to the province or country, sparking privacy debates, legal scrutiny, and practical advice on how IP addresses work, what data they reveal, and how individuals can safeguard their online anonymity.
Learn how to view and interpret IP addresses on Windows and Linux using commands like ipconfig, ifconfig, and ip addr, understand the differences between ifconfig and ip addr, explore IPv4 classes, CIDR notation, public vs private IPs, and MAC addresses, and network interface flags.
This article explains the technical distinction between bandwidth and broadband, how they relate to download and upload speeds, traffic calculations, upstream and downstream bandwidth, and the differences between internal and external IP addresses, providing clear formulas and practical examples.
This guide explains three straightforward command‑line methods—ifconfig, ip addr, and hostname -I—to reliably discover both local and remote IP addresses on a Linux system, helping with network configuration, troubleshooting, and security management.
Although you can obtain a website’s IP address, accessing it directly via HTTPS often fails because the HTTP request’s Host header differs, and servers use this header to verify the intended domain, leading to 403 errors unless the correct Host value is supplied.
This article presents six different PHP code snippets that demonstrate how to obtain a visitor's IP address using various server variables and environment functions, covering common scenarios such as proxies, CDN headers, and direct connections.
The article explains why storing IPv4 addresses as VARCHAR is suboptimal, demonstrates that a 32‑bit unsigned INT perfectly fits an IPv4 address, compares storage size and query performance, and shows how to use MySQL's inet_aton and inet_ntoa conversion functions.
This article explains why EKS clusters can run out of pod IP addresses or have low pod density per node, describes how AWS ENI and address‑prefix features affect IP allocation, and provides practical steps such as secondary CIDR allocation and subnet reservation to overcome these limits.
This article explains the fundamentals of IP addressing, why IPv4 addresses like 192.168.xx.xx are so common, how IPv4 is structured, the historical classful system, CIDR notation, private versus public IP ranges, NAT translation, and practical ways to view your own IP on various devices.
This article explains why the loopback address 127.0.0.1 (and its alias localhost) can still be pinged without a network connection, describes the differences among 127.0.0.1, localhost and 0.0.0.0, and details the kernel mechanisms that handle local traffic.
This article explains how IP addresses are composed of network, subnet, and host parts, details the five IP classes (A‑E) with their ranges, default subnet masks, and shows how to determine if two addresses belong to the same subnet using binary AND operations.
This article explains how to obtain a user's IP address from an HttpServletRequest, handle proxy headers, and use the ip2region library to map the IP to province, city, or country, covering setup, Maven integration, code examples, caching strategies, and performance testing.
This article explains why using a 32‑bit UNSIGNED INT to store IPv4 addresses in MySQL saves space and improves query performance, outlines the trade‑offs such as readability, shows MySQL conversion functions, discusses IPv6 alternatives, and provides Java code for converting between string and numeric representations.
This guide explains how to view IP addresses on Windows and Linux, compares commands like ipconfig, ifconfig, and ip addr, and delves into networking fundamentals such as CIDR, public vs private IP ranges, MAC addresses, and interface flags.
This article explains how to obtain a user's IP address from an HttpServletRequest in Java, convert it to geographic location using the ip2region library, and provides detailed code examples, Maven setup, caching strategies, and performance testing procedures for backend developers.
Learn quick Bash commands and scripts to extract a server's IP address—using awk, grep, sed, or a custom shell script—to retrieve a single interface IP or list all network interfaces, complete with example outputs for typical Linux environments.
The article explains that using a 32‑bit UNSIGNED INT to store IPv4 addresses in MySQL saves space and improves indexing and range queries, outlines the conversion functions and their performance, discusses readability drawbacks, and provides Java code for bidirectional conversion between string and integer representations.
This article explains the purposes of MAC and IP addresses, how they are structured, their role in network communication, and why MAC addresses can be duplicated across different LANs while IP addresses remain unique within a network.
This article explains the relationship between URLs, IP addresses, and domain names, detailing how the DNS system resolves human‑readable addresses to numeric IPs, the structure of URLs, the history and hierarchy of DNS, and the step‑by‑step process of domain name resolution.
This article explains the nature of the 127.0.0.1 loopback address, why pinging it works without a physical network connection, the differences between 127.0.0.1, localhost and 0.0.0.0, and how the kernel processes loopback traffic using a virtual network interface.
This article explains the concepts of URLs, IP addresses, domain names, the DNS system, its hierarchical structure, and the step‑by‑step process of domain name resolution, providing a clear foundation for networking fundamentals and interview preparation.
The article explains why MySQL recommends storing IPv4 addresses as a 32‑bit UNSIGNED INT instead of strings, outlines space and query advantages, notes readability drawbacks, and demonstrates conversion using built‑in functions and Java utility code.
This article explains the concepts of URLs, domain names, IP addresses, and the DNS system, describing how human‑readable web addresses are translated into numeric IPs through a hierarchical name‑resolution process, and why this mechanism is essential for everyday Internet usage.
This article explains why web browsers use domain names instead of IP addresses, how the DNS system automatically resolves those names through a hierarchical namespace, the roles of hosts files, root and authoritative servers, query types, transport protocols, and practical lookup examples.
Accessing a service on the same host using 127.0.0.1 offers no performance advantage over using the host’s own IP address because the Linux kernel routes both destinations through the loopback interface, as demonstrated by source‑code analysis and packet‑capture experiments.
This article explains the purpose and representation of IP addresses, details binary‑decimal conversion methods, describes the five IP classes, subnet mask functions, private versus public address ranges, and provides step‑by‑step guidance on subnetting, VLSM, and CIDR calculations with examples.
The article explains why accessing Zhihu with its raw IP address is blocked while domain access works, covering CDN sharing, the importance of hostnames, and how the TLS SNI extension lets servers identify the intended website before establishing a connection.
This article explains how computers use MAC and IP addresses, subnet masks, ARP, hubs, switches, and routers to communicate across physical, data‑link, and network layers, illustrating the learning process with step‑by‑step examples and tables of address mappings.
This article explains how to view a machine's IP address on Windows and Linux, describes the structure and classification of IPv4 addresses, introduces CIDR subnetting, distinguishes public and private IP ranges, and clarifies the role and format of MAC addresses.
This article explains the technical distinction between bandwidth and broadband, shows how to convert bandwidth to download speed, clarifies the relationship among bandwidth, network speed, and traffic, and details upstream/downstream bandwidth, server bandwidth, and the differences between private and public IP addresses.
This article explains the difference between public and private IP addresses, details the IPv4 class A‑E ranges, describes why private networks often use 192.168.x.x, and introduces NAT as the mechanism that maps internal addresses to external ones for internet access.
This guide explains how to view the VirtualBox host‑only network, set a matching IP address in the Vagrantfile, reload the VM, and verify connectivity between the host and the virtual machine using ping commands.
This article explains the fundamental differences between the special IPv4 addresses 0.0.0.0 and 127.0.0.1, covering their classifications, typical usages such as default routing and loopback testing, and practical considerations for binding services in server environments.
This article explains the purpose and binary composition of IPv4 addresses, details class A‑E ranges, private address blocks, subnet masks, and provides step‑by‑step router configuration commands to establish network connectivity.
This article explains how to install the IP4R PostgreSQL extension via PGXS, describes its custom IP address and range data types, demonstrates common queries, functions, operators, and GiST indexing techniques, and compares its performance against bigint‑based lookups for efficient IP range handling.
This guide explains how to use a packet capture tool to monitor the QQ process, filter UDP traffic, and retrieve a friend’s IP address, including step‑by‑step instructions, screenshots, and tips for distinguishing public and private IP ranges.
This article walks through practical regular‑expression exercises, explains each solution with clear JavaScript examples, and then expands to real‑world patterns for matching dollar amounts, 24‑hour times, IP addresses, quoted strings, and HTML tags, offering tips for building robust regexes.
