问如何在epoll中使用c-ares？

EN

#include <ares.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXWAITING 1000 /* Max. number of parallel DNS queries */
#define MAXTRIES      3 /* Max. number of tries per domain */
#define TIMEOUT    3000 /* Max. number of ms for first try */
#define DNS_MAX_EVENTS 10000
#define DNS_MAX_SERVERS 2

#define SERVERS    "1.0.0.1,8.8.8.8" /* DNS server to use (Cloudflare & Google) */

static int nwaiting;

ares_socket_t dns_client_fds[ARES_GETSOCK_MAXNUM] = {0};
struct epoll_event ev, events[DNS_MAX_EVENTS];
int i,bitmask,nfds, epollfd, timeout, fd_count, ret;

static void
state_cb(void *data, int s, int read, int write)
{
    //printf("Change state fd %d read:%d write:%d\n", s, read, write);
}

static void
callback(void *arg, int status, int timeouts, struct hostent *host)
{
    nwaiting--;

    if(!host || status != ARES_SUCCESS){
        fprintf(stderr, "Failed to lookup %s\n", ares_strerror(status));
        return;
    }

    char ip[INET6_ADDRSTRLEN];

    if (host->h_addr_list[0] != NULL){
        inet_ntop(host->h_addrtype, host->h_addr_list[0], ip, sizeof(ip));
        printf("%s\n%s\n", host->h_name, ip);
    }
}

static void
wait_ares(ares_channel channel)
{    
    nfds=0;
    bitmask=0;
    for (i =0; i < DNS_MAX_SERVERS ; i++) {
        if (dns_client_fds[i] > 0) {
            if (epoll_ctl(epollfd, EPOLL_CTL_DEL, dns_client_fds[i], NULL) < 0) {
                continue;
            }
        }
    }
    memset(dns_client_fds, 0, sizeof(dns_client_fds));
    bitmask = ares_getsock(channel, dns_client_fds, DNS_MAX_SERVERS);
    for (i =0; i < DNS_MAX_SERVERS ; i++) {
       if (dns_client_fds[i] > 0) {
            ev.events = 0;
            if (ARES_GETSOCK_READABLE(bitmask, i)) {
                ev.events |= EPOLLIN;
            }
            if (ARES_GETSOCK_WRITABLE(bitmask, i)) {
                ev.events |= EPOLLOUT;
            }
            ev.data.fd = dns_client_fds[i];
            if (epoll_ctl(epollfd, EPOLL_CTL_ADD, dns_client_fds[i], &ev) < 0) {
                if(errno == EEXIST) {
                    nfds++;
                    continue;
                }
                continue;
            }
            nfds++;
        }
    }
    if(nfds==0)
    {
        return;
    }
    timeout = 1000;//millisecs
    fd_count = epoll_wait(epollfd, events, DNS_MAX_EVENTS, timeout);
    if (fd_count < 0) {
        return;
    }
    if (fd_count > 0) {
        for (i = 0; i < fd_count; ++i) {
            ares_process_fd(channel, ((events[i].events) & (EPOLLIN) ? events[i].data.fd:ARES_SOCKET_BAD), ((events[i].events) & (EPOLLOUT)? events[i].data.fd:ARES_SOCKET_BAD));
        }
    } else {
        ares_process_fd(channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
    }   
}

int
main(int argc, char *argv[])
{
    FILE * fp;
    char domain[128];
    size_t len = 0;
    ssize_t read;
    ares_channel channel;
    int status, done = 0;
    int optmask;
    
    status = ares_library_init(ARES_LIB_INIT_ALL);
    if (status != ARES_SUCCESS) {
        printf("ares_library_init: %s\n", ares_strerror(status));
        return 1;
    }

    struct ares_options options = {
        .timeout = TIMEOUT,     /* set first query timeout */
        .tries = MAXTRIES       /* set max. number of tries */
    };
    optmask = ARES_OPT_TIMEOUTMS | ARES_OPT_TRIES;

    status = ares_init_options(&channel, &options, optmask);
    if (status != ARES_SUCCESS) {
        printf("ares_init_options: %s\n", ares_strerror(status));
        return 1;
    }

    status = ares_set_servers_csv(channel, SERVERS);
    if (status != ARES_SUCCESS) {
        printf("ares_set_servers_csv: %s\n", ares_strerror(status));
        return 1;
    }
    
    
    fp = fopen(argv[1], "r");
    if (!fp)
        exit(EXIT_FAILURE);
    memset(dns_client_fds, 0, sizeof(dns_client_fds));
    memset((char *)&ev, 0, sizeof(struct epoll_event));
    memset((char *)&events[0], 0, sizeof(events));

    epollfd = epoll_create(DNS_MAX_SERVERS);
    if (epollfd < 0) {
        perror("epoll_create: ");
    }
    

    do {
        if (nwaiting >= MAXWAITING || done) {
            do {
                wait_ares(channel);
            } while (nwaiting > MAXWAITING);
        }

        if (!done) {
            if (fscanf(fp, "%127s", domain) == 1) {
                ares_gethostbyname(channel, domain, AF_INET, callback, NULL);
                nwaiting++;
            } else {
                fprintf(stderr, "done sending\n");
                done = 1;
            }
        }
    } while (nwaiting > 0);

    ares_destroy(channel);
    ares_library_cleanup();
    
    fclose(fp);

    return 0;
}