An IPv4 address is 32 bits wide. It is divided into a Network ID portion and a Host ID portion. The split point is determined by the subnet mask.

In CIDR notation (Classless Inter-Domain Routing), the address is written as 192.168.1.10/24 where /24 means the first 24 bits form the Network ID. This gives 254 usable host addresses (256 minus 2 reserved).

In any subnet, two addresses are always reserved and cannot be assigned to any host:

For the network 204.152.189.0/24, valid host addresses run from 204.152.189.1 to 204.152.189.254 — that is 254 usable addresses.

Loopback Address in Action

When you send data to 127.0.0.1, the kernel never places the packet on the wire. It loops it back internally. This is extremely useful when developing and testing socket programs — both the client and server run on the same machine.

Wildcard Address — INADDR_ANY

A multihomed host is a computer with multiple network interfaces (e.g., eth0 with 192.168.1.5 and eth1 with 10.0.0.5). If a server binds to a specific IP, it only receives packets arriving on that interface. Binding to INADDR_ANY (0.0.0.0) allows the server to receive packets from any of the host’s network interfaces.

Subnetting allows an organization to divide its assigned IP block into smaller sub-networks. Instead of having one big flat network, you create multiple smaller segments (subnets), each identified by an extended network ID = Network ID + Subnet ID.

In this example, we took the assigned block 204.152.189.0/24 and split the 8-bit Host ID into a 4-bit Subnet ID and a 4-bit Host ID. The subnet mask becomes /28 (28 leading 1s = 255.255.255.240).

Subnets Created

In Linux socket programming, these constants are defined in <netinet/in.h>. Here is how they are used when creating a TCP server:

#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_in addr;

    /* Step 1: Create a TCP socket */
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Fill in address structure */
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(PORT);

    /*
     * INADDR_ANY = 0.0.0.0
     * The server will accept connections on ALL interfaces.
     * Change to INADDR_LOOPBACK (127.0.0.1) to accept
     * only local (loopback) connections.
     */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    /* OR: addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); */

    /* Step 3: Bind the socket to the address */
    if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on ALL interfaces, port %d\n", PORT);

    /* Step 4: Listen and accept (simplified) */
    listen(server_fd, 5);

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

    close(server_fd);
    return 0;
}

Key points:

• htonl() converts the constant from host byte order to network byte order (big-endian).
• AF_INET specifies IPv4. Use AF_INET6 for IPv6.
• INADDR_ANY binds to all interfaces — ideal for production servers.
• INADDR_LOOPBACK restricts to local connections — ideal for testing.