An IPv4 address like 204.152.189.116 is easy for you to type and read. But internally, the Linux kernel stores it as a 32-bit integer in network byte order (big-endian). An IPv6 address like ::1 is stored as a 128-bit value in struct in6_addr.

The three presentation formats you will encounter:

The flow of conversion:

Both functions are declared in <arpa/inet.h>.

#include <arpa/inet.h>

/* Presentation string --> Binary */
int inet_pton(int domain, const char *src_str, void *addrptr);
/*
 * domain  : AF_INET (IPv4) or AF_INET6 (IPv6)
 * src_str : e.g. "192.168.1.10" or "::1"
 * addrptr : pointer to struct in_addr  (for AF_INET)
 *           pointer to struct in6_addr (for AF_INET6)
 *
 * Returns:
 *   1  -> success
 *   0  -> src_str not in valid presentation format
 *  -1  -> error (check errno)
 */

/* Binary --> Presentation string */
const char *inet_ntop(int domain, const void *addrptr,
                      char *dst_str, size_t len);
/*
 * domain  : AF_INET or AF_INET6
 * addrptr : pointer to struct in_addr or struct in6_addr
 * dst_str : output buffer for the string
 * len     : size of dst_str buffer
 *
 * Returns:
 *   pointer to dst_str -> success
 *   NULL               -> error (errno = ENOSPC if buffer too small)
 */

Notice that inet_pton() returns three different values: 1, 0, or -1. Always check all three. Returning 0 means the string was not a valid IP address — that is not an error in the Unix sense, errno is not set in that case.

When using inet_ntop() you must provide an output buffer. To avoid guessing the size, use the two constants defined in <netinet/in.h>:

#include <netinet/in.h>

#define INET_ADDRSTRLEN  16   /* Max IPv4 dotted-decimal string length */
                              /* e.g. "255.255.255.255\0" = 16 bytes   */

#define INET6_ADDRSTRLEN 46   /* Max IPv6 hex string length            */
                              /* includes colons, \0 terminator        */

Always use these constants instead of hardcoding numbers like char buf[50]. It makes your code portable and self-documenting.

Example 1 – inet_pton() with IPv4

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

int main(void)
{
    struct in_addr addr;   /* 32-bit IPv4 binary */
    int result;

    const char *ipstr = "192.168.1.10";

    result = inet_pton(AF_INET, ipstr, &addr);

    if (result == 1) {
        /* addr.s_addr now holds the IPv4 address in network byte order */
        printf("Conversion OK. Binary (hex) = 0x%08X\n",
               ntohl(addr.s_addr));   /* ntohl for display only */
    } else if (result == 0) {
        printf("Not a valid IPv4 presentation string: %s\n", ipstr);
    } else {
        perror("inet_pton");
    }

    return 0;
}
/* Output:
 * Conversion OK. Binary (hex) = 0xC0A8010A
 */

Example 2 – inet_ntop() with IPv4

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

int main(void)
{
    struct in_addr addr;
    char buf[INET_ADDRSTRLEN];   /* Use the constant, not a magic number */

    /* Manually set binary address: 8.8.8.8 */
    addr.s_addr = htonl(0x08080808);

    if (inet_ntop(AF_INET, &addr, buf, sizeof(buf)) == NULL) {
        perror("inet_ntop");
        return 1;
    }

    printf("IP address string: %s\n", buf);
    /* Output: IP address string: 8.8.8.8 */

    return 0;
}

Example 3 – inet_pton() and inet_ntop() with IPv6

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

int main(void)
{
    struct in6_addr addr6;
    char buf[INET6_ADDRSTRLEN];

    const char *ipv6str = "2001:db8::1";

    /* Step 1: presentation --> binary */
    if (inet_pton(AF_INET6, ipv6str, &addr6) != 1) {
        fprintf(stderr, "inet_pton failed\n");
        return 1;
    }

    /* Step 2: binary --> presentation (round-trip check) */
    if (inet_ntop(AF_INET6, &addr6, buf, sizeof(buf)) == NULL) {
        perror("inet_ntop");
        return 1;
    }

    printf("Original : %s\n", ipv6str);
    printf("Round-trip: %s\n", buf);
    /* Note: kernel may normalize, e.g. "2001:db8::1" stays "2001:db8::1" */

    return 0;
}

Example 4 – Practical logging use case

A common real-world use: you receive a connection and want to log the client’s IP without doing a DNS lookup (which is slow).

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

void log_client_address(struct sockaddr_in *client_addr)
{
    char ip_str[INET_ADDRSTRLEN];

    if (inet_ntop(AF_INET,
                  &client_addr->sin_addr,
                  ip_str,
                  sizeof(ip_str)) == NULL) {
        /* Fall back gracefully */
        snprintf(ip_str, sizeof(ip_str), "(unknown)");
    }

    printf("[LOG] Client connected from %s port %d\n",
           ip_str,
           ntohs(client_addr->sin_port));
}

This is exactly the pattern used in the TLPI i6d_ucase_sv.c server shown in the next part of this chapter.

inet_ntoa() is particularly dangerous in multi-threaded programs because it uses an internal static buffer — two threads calling it simultaneously will corrupt each other’s result. inet_ntop() takes a caller-supplied buffer, so it is completely thread-safe.