An IPv6 address is 128 bits long. It is written as eight groups of four hexadecimal digits, separated by colons:

Each group is written in hexadecimal. Leading zeros within a group can be dropped (so 000A becomes A). Consecutive groups of all zeros can be replaced with :: (double colon). The example above becomes F000::A:1.

Important rule: The :: shortcut can only appear once in an address. If it appeared more than once, it would be ambiguous — the reader would not know how many zero groups each :: replaces.

::1 is 127 zero bits followed by a single 1-bit — the IPv6 loopback address. :: is all 128 bits set to zero — the IPv6 wildcard address.

During the transition from IPv4 to IPv6, many hosts still only support IPv4. IPv6 provides a special mechanism called IPv4-mapped IPv6 addresses so that IPv6 applications can communicate with IPv4-only hosts.

The format is: 80 zero bits, followed by 16 bits of FFFF, followed by the 32-bit IPv4 address written in dotted-decimal notation. When writing it as a string, the IPv4 portion is kept in dotted-decimal rather than being converted to hex — this makes it easier to read.

Why Is This Useful?

An IPv6 server socket (AF_INET6) can receive connections from IPv4 clients when the OS maps the client’s IPv4 address into IPv4-mapped IPv6 format automatically. This allows a single server to handle both IPv4 and IPv6 clients without running two separate server sockets.

Creating an IPv6 TCP server uses AF_INET6 and struct sockaddr_in6:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>

#define PORT 8080

int main() {
    int server_fd;
    struct sockaddr_in6 addr6;
    char addr_str[INET6_ADDRSTRLEN];

    /* Create an IPv6 TCP socket */
    server_fd = socket(AF_INET6, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    /* Fill in IPv6 address structure */
    memset(&addr6, 0, sizeof(addr6));
    addr6.sin6_family = AF_INET6;
    addr6.sin6_port   = htons(PORT);

    /*
     * in6addr_any is the IPv6 wildcard address (::)
     * Accepts connections on all interfaces for both IPv4 and IPv6
     * when IPV6_V6ONLY socket option is 0 (default on Linux).
     */
    addr6.sin6_addr = in6addr_any;
    /* OR use loopback: addr6.sin6_addr = in6addr_loopback; */

    if (bind(server_fd,
             (struct sockaddr *)&addr6, sizeof(addr6)) == -1) {
        perror("bind");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("IPv6 server bound to port %d\n", PORT);
    listen(server_fd, 5);

    /* ... accept() loop goes here ... */

    close(server_fd);
    return 0;
}

Address Conversion: inet_pton / inet_ntop

Unlike IPv4 where we used inet_addr(), for both IPv4 and IPv6 the modern functions are inet_pton() (text to binary) and inet_ntop() (binary to text):

#include <stdio.h>
#include <arpa/inet.h>

int main() {
    struct in6_addr addr6;
    char text[INET6_ADDRSTRLEN];
    const char *ipv6_str  = "F000::A:1";
    const char *ipv4mapped = "::FFFF:204.152.189.116";

    /* Convert text to binary */
    if (inet_pton(AF_INET6, ipv6_str, &addr6) == 1) {
        printf("Conversion OK\n");
    }

    /* Convert binary back to text */
    if (inet_ntop(AF_INET6, &addr6, text, sizeof(text)) != NULL) {
        printf("Address: %s\n", text);
    }

    /* Convert an IPv4-mapped address */
    if (inet_pton(AF_INET6, ipv4mapped, &addr6) == 1) {
        inet_ntop(AF_INET6, &addr6, text, sizeof(text));
        printf("IPv4-mapped: %s\n", text);
    }

    return 0;
}

Key difference from IPv4: Use AF_INET for IPv4 addresses and AF_INET6 for IPv6 addresses with these functions.