Great question! Let's break this down clearly, since it touches on IPv6/IPv4 compatibility and how system macros handle these addresses.

First: Yes, functionally it points to localhost #

The address ::ffff:127.0.0.1 is an IPv4-mapped IPv6 address—part of the reserved range in IPv6 for backward compatibility with IPv4. When you use this address, your network stack will route traffic to the IPv4 loopback interface (same as 127.0.0.1). So in practical terms, connecting to ::ffff:127.0.0.1 is identical to connecting to localhost via IPv4.

Why IN6_IS_ADDR_LOOPBACK doesn't recognize it #

Here's the catch: the IN6_IS_ADDR_LOOPBACK macro is strictly defined to check for the pure IPv6 loopback address ::1. Under the hood, it verifies that the first 127 bits of the IPv6 address are 0, and the final bit is 1.

For ::ffff:127.0.0.1, the address structure looks like this (in 16-byte form):

• First 104 bits: 0
• Next 16 bits: 0xffff
• Final 32 bits: 127.0.0.1 (in network byte order)

This doesn't match the ::1 pattern, so the macro returns false—even though the address functionally points to localhost.

How to detect it as localhost #

If you want your code to recognize both ::1 and IPv4-mapped loopback addresses, you'll need to add an extra check:

1. First use IN6_IS_ADDR_LOOPBACK to catch pure IPv6 loopback addresses.
2. Then check if the address is an IPv4-mapped IPv6 address (using IN6_IS_ADDR_V4MAPPED), and verify that the embedded IPv4 address falls within the 127.0.0.0/8 loopback range.

Here's a modified version of your C program that does this:

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

// Helper function to check if an address is localhost (supports IPv4/IPv6)
int is_localhost(const struct sockaddr *addr) {
    if (addr->sa_family == AF_INET) {
        const struct sockaddr_in *v4_addr = (const struct sockaddr_in *)addr;
        // Check if IPv4 address is in 127.0.0.0/8
        return (ntohl(v4_addr->sin_addr.s_addr) & 0xFF000000) == 0x7F000000;
    } else if (addr->sa_family == AF_INET6) {
        const struct sockaddr_in6 *v6_addr = (const struct sockaddr_in6 *)addr;
        
        // Check for pure IPv6 loopback (::1)
        if (IN6_IS_ADDR_LOOPBACK(&v6_addr->sin6_addr)) {
            return 1;
        }
        
        // Check for IPv4-mapped address with loopback IPv4
        if (IN6_IS_ADDR_V4MAPPED(&v6_addr->sin6_addr)) {
            struct in_addr embedded_v4;
            memcpy(&embedded_v4.s_addr, v6_addr->sin6_addr.s6_addr + 12, sizeof(embedded_v4.s_addr));
            return (ntohl(embedded_v4.s_addr) & 0xFF000000) == 0x7F000000;
        }
    }
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <address>\n", argv[0]);
        return EXIT_FAILURE;
    }

    struct addrinfo hints = {0};
    hints.ai_family = AF_UNSPEC; // Allow both IPv4 and IPv6
    hints.ai_socktype = SOCK_STREAM;

    struct addrinfo *results;
    int err = getaddrinfo(argv[1], NULL, &hints, &results);
    if (err != 0) {
        fprintf(stderr, "getaddrinfo error: %s\n", gai_strerror(err));
        return EXIT_FAILURE;
    }

    // Iterate through all returned addresses
    for (struct addrinfo *addr = results; addr != NULL; addr = addr->ai_next) {
        if (is_localhost(addr->ai_addr)) {
            printf("✅ Address '%s' is localhost\n", argv[1]);
        } else {
            printf("❌ Address '%s' is NOT localhost\n", argv[1]);
        }
    }

    freeaddrinfo(results);
    return EXIT_SUCCESS;
}

Testing this code #

If you compile and run this:

• ./your-program ::1 → Will report it's localhost
• ./your-program 127.0.0.1 → Will report it's localhost
• ./your-program ::ffff:127.0.0.1 → Will correctly report it's localhost

This covers all the common localhost address variants across IPv4 and IPv6.

内容的提问来源于stack exchange，提问作者Claudi