gai_error(3)

—

Options · 17

GAI_WAIT	Perform the look-ups synchronously. The call blocks until the look-ups have completed.
GAI_NOWAIT	Perform the look-ups asynchronously. The call returns immediately, and the requests are resolved in the background. See the discussion of the sevp argument below.
SIGEV_NONE	Don't provide any notification.
SIGEV_SIGNAL	When a look-up completes, generate the signal sigev_signo for the process. See sigevent(3type) for general details. The si_code field of the siginfo_t structure will be set to SI_ASYNCNL.
SIGEV_THREAD	When a look-up completes, invoke sigev_notify_function as if it were the start function of a new thread. See sigevent(3type) for details.
•	One or more of the operations in list completes.
•	The call is interrupted by a signal that is caught.
•	The time interval specified in timeout elapses. This argument specifies a timeout in seconds plus nanoseconds (see nanosleep(2) for details of the timespec structure). If timeout is NULL, then the call blocks indefinitely (until one of the events above occurs).
EAI_AGAIN	The resources necessary to enqueue the look-up requests were not available. The application may check the error status of each request to determine which ones failed.
EAI_MEMORY	Out of memory.
EAI_SYSTEM	mode is invalid.
EAI_AGAIN	The given timeout expired before any of the requests could be completed.
EAI_ALLDONE	There were no actual requests given to the function.
EAI_INTR	A signal has interrupted the function. Note that this interruption might have been caused by signal notification of some completed look-up request.
EAI_CANCELED	The request has been canceled successfully.
EAI_NOTCANCELED	The request has not been canceled.
EAI_ALLDONE	The request has already completed.

NAME

getaddrinfo_a, gai_suspend, gai_error, gai_cancel - asynchronous network address and service translation

LIBRARY

Asynchronous name lookup library (libanl, -lanl)

SYNOPSIS

bash

#define _GNU_SOURCE\n         /* See feature_test_macros(7) */
\n#include <netdb.h>

bash

int getaddrinfo_a(int \nmode\n, struct gaicb *\nlist\n[restrict],\n
\n                  int \nnitems\n, struct sigevent *restrict \nsevp\n);\n
\nint gai_suspend(const struct gaicb *const \nlist\n[], int \nnitems\n,\n
\n                  const struct timespec *\ntimeout\n);

bash

int gai_error(struct gaicb *\nreq\n);\n
\nint gai_cancel(struct gaicb *\nreq\n);

The getaddrinfo_a() function performs the same task as getaddrinfo(3), but allows multiple name look-ups to be performed asynchronously, with optional notification on completion of look-up operations.

The mode argument has one of the following values:

GAI_WAIT: Perform the look-ups synchronously. The call blocks until the look-ups have completed.
GAI_NOWAIT: Perform the look-ups asynchronously. The call returns immediately, and the requests are resolved in the background. See the discussion of the sevp argument below.

The array list specifies the look-up requests to process. The nitems argument specifies the number of elements in list. The requested look-up operations are started in parallel. NULL elements in list are ignored. Each request is described by a gaicb structure, defined as follows:

bash

struct gaicb {
\n
    const char            *ar_name;
\n
    const char            *ar_service;
\n
    const struct addrinfo *ar_request;
\n
    struct addrinfo       *ar_result;
};

The elements of this structure correspond to the arguments of getaddrinfo(3). Thus, ar_name corresponds to the node argument and ar_service to the service argument, identifying an Internet host and a service. The ar_request element corresponds to the hints argument, specifying the criteria for selecting the returned socket address structures. Finally, ar_result corresponds to the res argument; you do not need to initialize this element, it will be automatically set when the request is resolved. The addrinfo structure referenced by the last two elements is described in getaddrinfo(3).

When mode is specified as GAI_NOWAIT, notifications about resolved requests can be obtained by employing the sigevent structure pointed to by the sevp argument. For the definition and general details of this structure, see sigevent(3type). The sevp->sigev_notify field can have the following values:

SIGEV_NONE: Don't provide any notification.
SIGEV_SIGNAL: When a look-up completes, generate the signal sigev_signo for the process. See sigevent(3type) for general details. The si_code field of the siginfo_t structure will be set to SI_ASYNCNL.
SIGEV_THREAD: When a look-up completes, invoke sigev_notify_function as if it were the start function of a new thread. See sigevent(3type) for details.

For SIGEV_SIGNAL and SIGEV_THREAD, it may be useful to point sevp->sigev_value.sival_ptr to list.

The gai_suspend() function suspends execution of the calling thread, waiting for the completion of one or more requests in the array list. The nitems argument specifies the size of the array list. The call blocks until one of the following occurs:

•: One or more of the operations in list completes.
•: The call is interrupted by a signal that is caught.
•: The time interval specified in timeout elapses. This argument specifies a timeout in seconds plus nanoseconds (see nanosleep(2) for details of the timespec structure). If timeout is NULL, then the call blocks indefinitely (until one of the events above occurs).

No explicit indication of which request was completed is given; you must determine which request(s) have completed by iterating with gai_error() over the list of requests.

The gai_error() function returns the status of the request req: either EAI_INPROGRESS if the request was not completed yet, 0 if it was handled successfully, or an error code if the request could not be resolved.

The gai_cancel() function cancels the request req. If the request has been canceled successfully, the error status of the request will be set to EAI_CANCELED and normal asynchronous notification will be performed. The request cannot be canceled if it is currently being processed; in that case, it will be handled as if gai_cancel() has never been called. If req is NULL, an attempt is made to cancel all outstanding requests that the process has made.

RETURN VALUE

The getaddrinfo_a() function returns 0 if all of the requests have been enqueued successfully, or one of the following nonzero error codes:

EAI_AGAIN: The resources necessary to enqueue the look-up requests were not available. The application may check the error status of each request to determine which ones failed.
EAI_MEMORY: Out of memory.
EAI_SYSTEM: mode is invalid.

The gai_suspend() function returns 0 if at least one of the listed requests has been completed. Otherwise, it returns one of the following nonzero error codes:

EAI_AGAIN: The given timeout expired before any of the requests could be completed.
EAI_ALLDONE: There were no actual requests given to the function.
EAI_INTR: A signal has interrupted the function. Note that this interruption might have been caused by signal notification of some completed look-up request.

The gai_error() function can return EAI_INPROGRESS for an unfinished look-up request, 0 for a successfully completed look-up (as described above), one of the error codes that could be returned by getaddrinfo(3), or the error code EAI_CANCELED if the request has been canceled explicitly before it could be finished.

The gai_cancel() function can return one of these values:

EAI_CANCELED: The request has been canceled successfully.
EAI_NOTCANCELED: The request has not been canceled.
EAI_ALLDONE: The request has already completed.

The gai_strerror(3) function translates these error codes to a human readable string, suitable for error reporting.

ATTRIBUTES

For an explanation of the terms used in this section, see attributes(7).

Interface	Attribute	Value
getaddrinfo_a (), gai_suspend (), gai_error (), gai_cancel ()	Thread safety	MT-Safe

$ \n./a.out mirrors.kernel.org enoent.linuxfoundation.org gnu.org\n
mirrors.kernel.org: 139.178.88.99
enoent.linuxfoundation.org: Name or service not known
gnu.org: 209.51.188.116

Here is the program source code

bash

#define _GNU_SOURCE
#include <err.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MALLOC(n, type)  ((type *) reallocarray(NULL, n, sizeof(type)))
int
main(int argc, char *argv[])
{
\n
    int ret;
\n
    struct gaicb *reqs[argc - 1];
\n
    char host[NI_MAXHOST];
\n
    struct addrinfo *res;
\n
    if (argc < 2) {
\n
        fprintf(stderr, "Usage: %s HOST...\n", argv[0]);
\n
        exit(EXIT_FAILURE);
\n
    }
\n
    for (size_t i = 0; i < argc - 1; i++) {
\n
        reqs[i] = MALLOC(1, struct gaicb);
\n
        if (reqs[i] == NULL)
\n
            err(EXIT_FAILURE, "malloc");
\n
        memset(reqs[i], 0, sizeof(*reqs[0]));
\n
        reqs[i]->ar_name = argv[i + 1];
\n
    }
\n
    ret = getaddrinfo_a(GAI_WAIT, reqs, argc - 1, NULL);
\n
    if (ret != 0) {
\n
        fprintf(stderr, "getaddrinfo_a() failed: %s\n",
\n
                gai_strerror(ret));
\n
        exit(EXIT_FAILURE);
\n
    }
\n
    for (size_t i = 0; i < argc - 1; i++) {
\n
        printf("%s: ", reqs[i]->ar_name);
\n
        ret = gai_error(reqs[i]);
\n
        if (ret == 0) {
\n
            res = reqs[i]->ar_result;
\n
            ret = getnameinfo(res->ai_addr, res->ai_addrlen,
\n
                              host, sizeof(host),
\n
                              NULL, 0, NI_NUMERICHOST);
\n
            if (ret != 0) {
\n
                fprintf(stderr, "getnameinfo() failed: %s\n",
\n
                        gai_strerror(ret));
\n
                exit(EXIT_FAILURE);
\n
            }
\n
            puts(host);
\n
        } else {
\n
            puts(gai_strerror(ret));
\n
        }
\n
    }
\n
    exit(EXIT_SUCCESS);
}

Asynchronous example

This example shows a simple interactive getaddrinfo_a() front-end. The notification facility is not demonstrated.

An example session might look like this:

bash

$ \n./a.out\n
> a mirrors.kernel.org enoent.linuxfoundation.org gnu.org
> c 2
[2] gnu.org: Request not canceled
> w 0 1
[00] mirrors.kernel.org: Finished
> l
[00] mirrors.kernel.org: 139.178.88.99
[01] enoent.linuxfoundation.org: Processing request in progress
[02] gnu.org: 209.51.188.116
> l
[00] mirrors.kernel.org: 139.178.88.99
[01] enoent.linuxfoundation.org: Name or service not known
[02] gnu.org: 209.51.188.116

The program source is as follows:

bash

#define _GNU_SOURCE
#include <assert.h>
#include <err.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CALLOC(n, type)  ((type *) calloc(n, sizeof(type)))
#define REALLOCF(ptr, n, type)                                          \
({                                                                      \
\n
    static_assert(__builtin_types_compatible_p(typeof(ptr), type *));   \
\n
                                                                        \
\n
    (type *) reallocarrayf(ptr, n, sizeof(type));                       \
})
static struct gaicb **reqs = NULL;
static size_t nreqs = 0;
static inline void *
reallocarrayf(void *p, size_t nmemb, size_t size)
{
\n
    void  *q;
\n
    q = reallocarray(p, nmemb, size);
\n
    if (q == NULL && nmemb != 0 && size != 0)
\n
        free(p);
\n
    return q;
}
static char *
getcmd(void)
{
\n
    static char buf[256];
\n
    fputs("> ", stdout); fflush(stdout);
\n
    if (fgets(buf, sizeof(buf), stdin) == NULL)
\n
        return NULL;
\n
    if (buf[strlen(buf) - 1] == '\n')
\n
        buf[strlen(buf) - 1] = 0;
\n
    return buf;
}
/* Add requests for specified hostnames. */
static void
add_requests(void)
{
\n
    size_t nreqs_base = nreqs;
\n
    char *host;
\n
    int ret;
\n
    while ((host = strtok(NULL, " "))) {
\n
        nreqs++;
\n
        reqs = REALLOCF(reqs, nreqs, struct gaicb *);
\n
        if (reqs == NULL)
\n
            err(EXIT_FAILURE, "reallocf");
\n
        reqs[nreqs - 1] = CALLOC(1, struct gaicb);
\n
        if (reqs[nreqs - 1] == NULL)
\n
            err(EXIT_FAILURE, "calloc");
\n
        reqs[nreqs - 1]->ar_name = strdup(host);
\n
    }
\n
    /* Queue nreqs_base..nreqs requests. */
\n
    ret = getaddrinfo_a(GAI_NOWAIT, &reqs[nreqs_base],
\n
                        nreqs - nreqs_base, NULL);
\n
    if (ret) {
\n
        fprintf(stderr, "getaddrinfo_a() failed: %s\n",
\n
                gai_strerror(ret));
\n
        exit(EXIT_FAILURE);
\n
    }
}
/* Wait until at least one of specified requests completes. */
static void
wait_requests(void)
{
\n
    char *id;
\n
    int ret;
\n
    size_t n;
\n
    struct gaicb const **wait_reqs;
\n
    wait_reqs = CALLOC(nreqs, const struct gaicb *);
\n
    if (wait_reqs == NULL)
\n
        err(EXIT_FAILURE, "calloc");
\n
                /* NULL elements are ignored by gai_suspend(). */
\n
    while ((id = strtok(NULL, " ")) != NULL) {
\n
        n = atoi(id);
\n
        if (n >= nreqs) {
\n
            printf("Bad request number: %s\n", id);
\n
            return;
\n
        }
\n
        wait_reqs[n] = reqs[n];
\n
    }
\n
    ret = gai_suspend(wait_reqs, nreqs, NULL);
\n
    if (ret) {
\n
        printf("gai_suspend(): %s\n", gai_strerror(ret));
\n
        return;
\n
    }
\n
    for (size_t i = 0; i < nreqs; i++) {
\n
        if (wait_reqs[i] == NULL)
\n
            continue;
\n
        ret = gai_error(reqs[i]);
\n
        if (ret == EAI_INPROGRESS)
\n
            continue;
\n
        printf("[%02zu] %s: %s\n", i, reqs[i]->ar_name,
\n
               ret == 0 ? "Finished" : gai_strerror(ret));
\n
    }
}
/* Cancel specified requests. */
static void
cancel_requests(void)
{
\n
    char *id;
\n
    int ret;
\n
    size_t n;
\n
    while ((id = strtok(NULL, " ")) != NULL) {
\n
        n = atoi(id);
\n
        if (n >= nreqs) {
\n
            printf("Bad request number: %s\n", id);
\n
            return;
\n
        }
\n
        ret = gai_cancel(reqs[n]);
\n
        printf("[%s] %s: %s\n", id, reqs[atoi(id)]->ar_name,
\n
               gai_strerror(ret));
\n
    }
}
/* List all requests. */
static void
list_requests(void)
{
\n
    int ret;
\n
    char host[NI_MAXHOST];
\n
    struct addrinfo *res;
\n
    for (size_t i = 0; i < nreqs; i++) {
\n
        printf("[%02zu] %s: ", i, reqs[i]->ar_name);
\n
        ret = gai_error(reqs[i]);
\n
        if (!ret) {
\n
            res = reqs[i]->ar_result;
\n
            ret = getnameinfo(res->ai_addr, res->ai_addrlen,
\n
                              host, sizeof(host),
\n
                              NULL, 0, NI_NUMERICHOST);
\n
            if (ret) {
\n
                fprintf(stderr, "getnameinfo() failed: %s\n",
\n
                        gai_strerror(ret));
\n
                exit(EXIT_FAILURE);
\n
            }
\n
            puts(host);
\n
        } else {
\n
            puts(gai_strerror(ret));
\n
        }
\n
    }
}
int
main(void)
{
\n
    char *cmdline;
\n
    char *cmd;
\n
    while ((cmdline = getcmd()) != NULL) {
\n
        cmd = strtok(cmdline, " ");
\n
        if (cmd == NULL) {
\n
            list_requests();
\n
        } else {
\n
            switch (cmd[0]) {
\n
            case 'a':
\n
                add_requests();
\n
                break;
\n
            case 'w':
\n
                wait_requests();
\n
                break;
\n
            case 'c':
\n
                cancel_requests();
\n
                break;
\n
            case 'l':
\n
                list_requests();
\n
                break;
\n
            default:
\n
                fprintf(stderr, "Bad command: %c\n", cmd[0]);
\n
                break;
\n
            }
\n
        }
\n
    }
\n
    exit(EXIT_SUCCESS);
}

NAME

LIBRARY

SYNOPSIS

DESCRIPTION

RETURN VALUE

ATTRIBUTES

STANDARDS

HISTORY

EXAMPLES

Synchronous example

Asynchronous example

SEE ALSO