When you type www.google.com in a browser, your computer needs to find the actual IP address (like 142.250.183.4) behind that name. This process is called host name resolution.

In C network programming, the traditional function to do this is gethostbyname(). It takes a hostname string and returns a structure packed with all the information about that host — its real (canonical) name, any aliases, and its IP addresses.

Note: gethostbyname() is old and considered obsolete today. The modern replacement is getaddrinfo(). But you will see gethostbyname() in older codebases, so it is important to understand it.

When your program calls gethostbyname("www.example.com"), here is what happens behind the scenes:

The C library first checks /etc/hosts for a local mapping, then checks /etc/resolv.conf to find the DNS server, and finally sends a UDP query to the DNS server to resolve the name.

Include <netdb.h> to use these functions:

#include <netdb.h>

struct hostent *gethostbyname(const char *name);

/* Error reporting helpers */
void herror(const char *str);
const char *hstrerror(int err);

/* On success: returns pointer to a statically allocated hostent structure
   On failure: returns NULL and sets h_errno (not errno) */

Important: Unlike most C functions that set errno on failure, gethostbyname() sets a separate global variable called h_errno. You must use hstrerror(h_errno) or herror() to print the error — not strerror(errno).

When gethostbyname() succeeds it returns a pointer to this structure:

struct hostent {
    char  *h_name;       /* Official (canonical) name of the host     */
    char **h_aliases;    /* NULL-terminated array of alias name        */
    int    h_addrtype;   /* Address type: AF_INET or AF_INET6          */
    int    h_length;     /* Length of each address in bytes            */
    char **h_addr_list;  /* NULL-terminated array of IP addresses      */
                         /* (in network byte order)                    */
};

/* Convenience macro (for compatibility with old code) */
#define h_addr h_addr_list[0]   /* First address in the list */

Key point: Both h_aliases and h_addr_list are arrays of pointers that end with a NULL pointer. You loop through them until you hit NULL.

This program takes hostnames as command-line arguments and prints all information returned by gethostbyname():

/* t_gethostbyname.c
 * Usage: ./t_gethostbyname www.google.com www.example.com
 *
 * Compile: gcc -o t_gethostbyname t_gethostbyname.c
 */

#define _BSD_SOURCE   /* Needed to expose hstrerror() in <netdb.h> */

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>        /* gethostbyname, struct hostent, h_errno */
#include <netinet/in.h>   /* struct in_addr, struct in6_addr        */
#include <arpa/inet.h>    /* inet_ntop()                             */

int main(int argc, char *argv[])
{
    struct hostent *h;
    char **pp;
    char str[INET6_ADDRSTRLEN];   /* Big enough for IPv6 address string */

    if (argc < 2) {
        fprintf(stderr, "Usage: %s hostname...\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* Loop through each hostname given on command line */
    for (argv++; *argv != NULL; argv++) {

        h = gethostbyname(*argv);

        if (h == NULL) {
            /* h_errno is set, NOT errno — use hstrerror() */
            fprintf(stderr, "gethostbyname() failed for '%s': %s\n",
                    *argv, hstrerror(h_errno));
            continue;   /* Try next hostname */
        }

        /* Print canonical name (official DNS name) */
        printf("Canonical name: %s\n", h->h_name);

        /* Print all aliases (e.g. www.example.com -> example.com) */
        printf("  alias(es): ");
        for (pp = h->h_aliases; *pp != NULL; pp++)
            printf(" %s", *pp);
        printf("\n");

        /* Print address family */
        printf("  address type: %s\n",
               (h->h_addrtype == AF_INET)  ? "AF_INET"  :
               (h->h_addrtype == AF_INET6) ? "AF_INET6" : "???");

        /* Print all IP addresses */
        if (h->h_addrtype == AF_INET || h->h_addrtype == AF_INET6) {
            printf("  address(es): ");
            for (pp = h->h_addr_list; *pp != NULL; pp++) {
                /* inet_ntop converts binary IP to printable string */
                printf(" %s",
                       inet_ntop(h->h_addrtype, *pp,
                                 str, INET6_ADDRSTRLEN));
            }
            printf("\n");
        }
    }

    exit(EXIT_SUCCESS);
}

Sample output:

$ ./t_gethostbyname www.jambit.com
Canonical name: jamjam1.jambit.com
  alias(es):  www.jambit.com
  address type: AF_INET
  address(es):  62.245.207.90

A focused example showing how to get just the first IP address:

#define _BSD_SOURCE
#include <stdio.h>
#include <netdb.h>
#include <arpa/inet.h>

int main(void)
{
    const char *hostname = "www.example.com";
    struct hostent *h;
    char buf[INET_ADDRSTRLEN];

    h = gethostbyname(hostname);
    if (h == NULL) {
        herror("gethostbyname");    /* herror() prints to stderr automatically */
        return 1;
    }

    /* h_addr is a macro for h_addr_list[0] */
    printf("First IP of %s: %s\n",
           hostname,
           inet_ntop(AF_INET, h->h_addr, buf, sizeof(buf)));

    return 0;
}

/* Expected output (actual IP may differ):
   First IP of www.example.com: 93.184.216.34
*/

These are set in h_errno when gethostbyname() returns NULL: