/***

  This file is part of libasyncns.

  Copyright 2005-2008 Lennart Poettering

  libasyncns is free software; you can redistribute it and/or modify

  it under the terms of the GNU Lesser General Public License as

  published by the Free Software Foundation, either version 2.1 of the

  License, or (at your option) any later version.

  libasyncns is distributed in the hope that it will be useful, but

  WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public

  License along with libasyncns. If not, see

  <http://www.gnu.org/licenses/>.

***/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/* #undef HAVE_PTHREAD */

#include <assert.h>

#include <fcntl.h>

#include <signal.h>

#include <unistd.h>

#include <sys/select.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <pwd.h>

#include <netinet/in.h>

#include <arpa/nameser.h>

#include <resolv.h>

#include <dirent.h>

/* Needed on Mac OS X where it is not included from arpa/nameser.h */

#if HAVE_ARPA_NAMESER_COMPAT_H

#include <arpa/nameser_compat.h>

#endif

#ifdef HAVE_SYS_PRCTL_H

#include <sys/prctl.h>

#endif

#if HAVE_PTHREAD

#include <pthread.h>

#endif

#include "asyncns.h"

#define MAX_WORKERS 16

#define MAX_QUERIES 256

#define BUFSIZE (10240)

typedef enum {

    REQUEST_ADDRINFO,

    RESPONSE_ADDRINFO,

    REQUEST_NAMEINFO,

    RESPONSE_NAMEINFO,

    REQUEST_RES_QUERY,

    REQUEST_RES_SEARCH,

    RESPONSE_RES,

    REQUEST_TERMINATE,

    RESPONSE_DIED

} query_type_t;

enum {

    REQUEST_RECV_FD = 0,

    REQUEST_SEND_FD = 1,

    RESPONSE_RECV_FD = 2,

    RESPONSE_SEND_FD = 3,

    MESSAGE_FD_MAX = 4

};

struct asyncns {

    int fds[4];

#ifndef HAVE_PTHREAD

    pid_t workers[MAX_WORKERS];

#else

    pthread_t workers[MAX_WORKERS];

#endif

    unsigned valid_workers;

    unsigned current_id, current_index;

    asyncns_query_t* queries[MAX_QUERIES];

    asyncns_query_t *done_head, *done_tail;

    int n_queries;

    int dead;

};

struct asyncns_query {

    asyncns_t *asyncns;

    int done;

    unsigned id;

    query_type_t type;

    asyncns_query_t *done_next, *done_prev;

    int ret;

    int _errno;

    int _h_errno;

    struct addrinfo *addrinfo;

    char *serv, *host;

    void *userdata;

};

typedef struct rheader {

    query_type_t type;

    unsigned id;

    size_t length;

} rheader_t;

typedef struct addrinfo_request {

    struct rheader header;

    int hints_is_null;

    int ai_flags;

    int ai_family;

    int ai_socktype;

    int ai_protocol;

    size_t node_len, service_len;

} addrinfo_request_t;

typedef struct addrinfo_response {

    struct rheader header;

    int ret;

    int _errno;

    int _h_errno;

    /* followed by addrinfo_serialization[] */

} addrinfo_response_t;

typedef struct addrinfo_serialization {

    int ai_flags;

    int ai_family;

    int ai_socktype;

    int ai_protocol;

    size_t ai_addrlen;

    size_t canonname_len;

    /* Followed by ai_addr amd ai_canonname with variable lengths */

} addrinfo_serialization_t;

typedef struct nameinfo_request {

    struct rheader header;

    int flags;

    socklen_t sockaddr_len;

    int gethost, getserv;

} nameinfo_request_t;

typedef struct nameinfo_response {

    struct rheader header;

    size_t hostlen, servlen;

    int ret;

    int _errno;

    int _h_errno;

} nameinfo_response_t;

typedef struct res_query_request {

    struct rheader header;

    int class;

    int type;

    size_t dname_len;

} res_request_t;

typedef struct res_query_response {

    struct rheader header;

    int ret;

    int _errno;

    int _h_errno;

} res_response_t;

#ifndef HAVE_STRNDUP

static char *strndup(const char *s, size_t l) {

    size_t a;

    char *n;

    a = strlen(s);

    if (a > l)

        a = l;

    if (!(n = malloc(a+1)))

        return NULL;

    memcpy(n, s, a);

    n[a] = 0;

    return n;

}

#endif

#ifndef HAVE_PTHREAD

static int close_allv(const int except_fds[]) {

    struct rlimit rl;

    int fd;

#ifdef __linux__

    DIR *d;

    assert(except_fds);

    if ((d = opendir("/proc/self/fd"))) {

        struct dirent *de;

        while ((de = readdir(d))) {

            int found;

            long l;

            char *e = NULL;

            int i;

            if (de->d_name[0] == '.')

                continue;

            errno = 0;

            l = strtol(de->d_name, &e, 10);

            if (errno != 0 || !e || *e) {

                closedir(d);

                errno = EINVAL;

                return -1;

            }

            fd = (int) l;

            if ((long) fd != l) {

                closedir(d);

                errno = EINVAL;

                return -1;

            }

            if (fd < 3)

                continue;

            if (fd == dirfd(d))

                continue;

            found = 0;

            for (i = 0; except_fds[i] >= 0; i++)

                if (except_fds[i] == fd) {

                    found = 1;

                    break;

                }

            if (found)

                continue;

            if (close(fd) < 0) {

                int saved_errno;

                saved_errno = errno;

                closedir(d);

                errno = saved_errno;

                return -1;

            }

        }

        closedir(d);

        return 0;

    }

#endif

    if (getrlimit(RLIMIT_NOFILE, &rl) < 0)

        return -1;

    for (fd = 0; fd < (int) rl.rlim_max; fd++) {

        int i;

        if (fd <= 3)

            continue;

        for (i = 0; except_fds[i] >= 0; i++)

            if (except_fds[i] == fd)

                continue;

        if (close(fd) < 0 && errno != EBADF)

            return -1;

    }

    return 0;

}

static int reset_sigsv(const int except[]) {

    int sig;

    assert(except);

    for (sig = 1; sig < NSIG; sig++) {

        int reset = 1;

        switch (sig) {

            case SIGKILL:

            case SIGSTOP:

                reset = 0;

                break;

            default: {

                int i;

                for (i = 0; except[i] > 0; i++) {

                    if (sig == except[i]) {

                        reset = 0;

                        break;

                    }

                }

            }

        }

        if (reset) {

            struct sigaction sa;

            memset(&sa, 0, sizeof(sa));

            sa.sa_handler = SIG_DFL;

            /* On Linux the first two RT signals are reserved by

             * glibc, and sigaction() will return EINVAL for them. */

            if ((sigaction(sig, &sa, NULL) < 0))

                if (errno != EINVAL)

                    return -1;

        }

    }

    return 0;

}

static int ignore_sigsv(const int ignore[]) {

    int i;

    assert(ignore);

    for (i = 0; ignore[i] > 0; i++) {

        struct sigaction sa;

        memset(&sa, 0, sizeof(sa));

        sa.sa_handler = SIG_IGN;

        if ((sigaction(ignore[i], &sa, NULL) < 0))

            return -1;

    }

    return 0;

}

#endif

static int fd_nonblock(int fd) {

    int i;

    assert(fd >= 0);

    if ((i = fcntl(fd, F_GETFL, 0)) < 0)

        return -1;

    if (i & O_NONBLOCK)

        return 0;

    return fcntl(fd, F_SETFL, i | O_NONBLOCK);

}

static int fd_cloexec(int fd) {

    int v;

    assert(fd >= 0);

    if ((v = fcntl(fd, F_GETFD, 0)) < 0)

        return -1;

    if (v & FD_CLOEXEC)

        return 0;

    return fcntl(fd, F_SETFD, v | FD_CLOEXEC);

}

static int send_died(int out_fd) {

    rheader_t rh;

    assert(out_fd > 0);

    memset(&rh, 0, sizeof(rh));

    rh.type = RESPONSE_DIED;

    rh.id = 0;

    rh.length = sizeof(rh);

    return send(out_fd, &rh, rh.length, 0);

}

static void *serialize_addrinfo(void *p, const struct addrinfo *ai, size_t *length, size_t maxlength) {

    addrinfo_serialization_t s;

    size_t cnl, l;

    assert(p);

    assert(ai);

    assert(length);

    assert(*length <= maxlength);

    cnl = (ai->ai_canonname ? strlen(ai->ai_canonname)+1 : 0);

    l = sizeof(addrinfo_serialization_t) + ai->ai_addrlen + cnl;

    if (*length + l > maxlength)

        return NULL;

    s.ai_flags = ai->ai_flags;

    s.ai_family = ai->ai_family;

    s.ai_socktype = ai->ai_socktype;

    s.ai_protocol = ai->ai_protocol;

    s.ai_addrlen = ai->ai_addrlen;

    s.canonname_len = cnl;

    memcpy((uint8_t*) p, &s, sizeof(addrinfo_serialization_t));

    memcpy((uint8_t*) p + sizeof(addrinfo_serialization_t), ai->ai_addr, ai->ai_addrlen);