/***

  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>

#include <sys/time.h>

#include <sys/resource.h>

#include <stdint.h>

#ifdef HAVE_SYS_PRCTL_H

#include <sys/prctl.h>

#endif

#if HAVE_PTHREAD

#include <pthread.h>

#endif

#include "asyncns.h"

#ifndef MSG_NOSIGNAL

#define MSG_NOSIGNAL 0

#endif

#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_request {

    struct rheader header;

    int class;

    int type;

    size_t dname_len;

} res_request_t;

typedef struct res_response {

    struct rheader header;

    int ret;

    int _errno;

    int _h_errno;

} res_response_t;

typedef union packet {

    rheader_t rheader;

    addrinfo_request_t addrinfo_request;

    addrinfo_response_t addrinfo_response;

    nameinfo_request_t nameinfo_request;

    nameinfo_response_t nameinfo_response;

    res_request_t res_request;

    res_response_t res_response;

} packet_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, maxfd;

#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)

        maxfd = (int) rl.rlim_max;

    else

        maxfd = sysconf(_SC_OPEN_MAX);

    for (fd = 3; fd < maxfd; fd++) {

        int i, found;

        found = 0;

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

            if (except_fds[i] == fd) {

                found = 1;

                continue;

            }

        if (found)

            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, MSG_NOSIGNAL);

}

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);

    if (ai->ai_canonname)

        strcpy((char*) p + sizeof(addrinfo_serialization_t) + ai->ai_addrlen, ai->ai_canonname);

    *length += l;

    return (uint8_t*) p + l;

}

static int send_addrinfo_reply(int out_fd, unsigned id, int ret, struct addrinfo *ai, int _errno, int _h_errno) {

    addrinfo_response_t data[BUFSIZE/sizeof(addrinfo_response_t) + 1];

    addrinfo_response_t *resp = data;

    assert(out_fd >= 0);

    memset(data, 0, sizeof(data));

    resp->header.type = RESPONSE_ADDRINFO;

    resp->header.id = id;

    resp->header.length = sizeof(addrinfo_response_t);

    resp->ret = ret;

    resp->_errno = _errno;

    resp->_h_errno = _h_errno;

    if (ret == 0 && ai) {

        void *p = data + 1;

        struct addrinfo *k;

        for (k = ai; k; k = k->ai_next) {

            if (!(p = serialize_addrinfo(p, k, &resp->header.length, (char*) data + BUFSIZE - (char*) p))) {

                resp->ret = EAI_MEMORY;

                break;

            }

        }

    }

    if (ai)

        freeaddrinfo(ai);

    return send(out_fd, resp, resp->header.length, MSG_NOSIGNAL);

}

static int send_nameinfo_reply(int out_fd, unsigned id, int ret, const char *host, const char *serv, int _errno, int _h_errno) {

    nameinfo_response_t data[BUFSIZE/sizeof(nameinfo_response_t) + 1];

    size_t hl, sl;

    nameinfo_response_t *resp = data;

    assert(out_fd >= 0);

    sl = serv ? strlen(serv)+1 : 0;

    hl = host ? strlen(host)+1 : 0;

    memset(data, 0, sizeof(data));

    resp->header.type = RESPONSE_NAMEINFO;

    resp->header.id = id;

    resp->header.length = sizeof(nameinfo_response_t) + hl + sl;

    resp->ret = ret;

    resp->_errno = _errno;

    resp->_h_errno = _h_errno;

    resp->hostlen = hl;

    resp->servlen = sl;

    assert(sizeof(data) >= resp->header.length);

    if (host)

        memcpy((uint8_t *)data + sizeof(nameinfo_response_t), host, hl);

    if (serv)

        memcpy((uint8_t *)data + sizeof(nameinfo_response_t) + hl, serv, sl);

    return send(out_fd, resp, resp->header.length, MSG_NOSIGNAL);

}

static int send_res_reply(int out_fd, unsigned id, const unsigned char *answer, int ret, int _errno, int _h_errno) {

    res_response_t data[BUFSIZE/sizeof(res_response_t) + 1];

    res_response_t *resp = data;

    assert(out_fd >= 0);

    memset(data, 0, sizeof(data));

    resp->header.type = RESPONSE_RES;

    resp->header.id = id;

    resp->header.length = sizeof(res_response_t) + (ret < 0 ? 0 : ret);

    resp->ret = ret;

    resp->_errno = _errno;

    resp->_h_errno = _h_errno;

    assert(sizeof(data) >= resp->header.length);

    if (ret > 0)

        memcpy((uint8_t *)data + sizeof(res_response_t), answer, ret);

    return send(out_fd, resp, resp->header.length, MSG_NOSIGNAL);

}

static int handle_request(int out_fd, const packet_t *packet, size_t length) {

    const rheader_t *req;

    assert(out_fd >= 0);

    req = &packet->rheader;

    assert(req);

    assert(length >= sizeof(rheader_t));

    assert(length == req->length);

    switch (req->type) {

        case REQUEST_ADDRINFO: {

            struct addrinfo ai, *result = NULL;

            const addrinfo_request_t *ai_req = &packet->addrinfo_request;

            const char *node, *service;

            int ret;

            assert(length >= sizeof(addrinfo_request_t));

            assert(length == sizeof(addrinfo_request_t) + ai_req->node_len + ai_req->service_len);

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

            ai.ai_flags = ai_req->ai_flags;

            ai.ai_family = ai_req->ai_family;

            ai.ai_socktype = ai_req->ai_socktype;

            ai.ai_protocol = ai_req->ai_protocol;

            node = ai_req->node_len ? (const char*) ai_req + sizeof(addrinfo_request_t) : NULL;

            service = ai_req->service_len ? (const char*) ai_req + sizeof(addrinfo_request_t) + ai_req->node_len : NULL;

            ret = getaddrinfo(node, service,

                              ai_req->hints_is_null ? NULL : &ai,

                              &result);

            /* send_addrinfo_reply() frees result */

            return send_addrinfo_reply(out_fd, req->id, ret, result, errno, h_errno);

        }

        case REQUEST_NAMEINFO: {

            int ret;

            const nameinfo_request_t *ni_req = &packet->nameinfo_request;

            char hostbuf[NI_MAXHOST], servbuf[NI_MAXSERV];

            struct sockaddr_storage sa;

            assert(length >= sizeof(nameinfo_request_t));

            assert(length == sizeof(nameinfo_request_t) + ni_req->sockaddr_len);

            memcpy(&sa, (const uint8_t *) ni_req + sizeof(nameinfo_request_t), ni_req->sockaddr_len);

            ret = getnameinfo((struct sockaddr *)&sa, ni_req->sockaddr_len,

                              ni_req->gethost ? hostbuf : NULL, ni_req->gethost ? sizeof(hostbuf) : 0,

                              ni_req->getserv ? servbuf : NULL, ni_req->getserv ? sizeof(servbuf) : 0,

                              ni_req->flags);

            return send_nameinfo_reply(out_fd, req->id, ret,

                                       ret == 0 && ni_req->gethost ? hostbuf : NULL,

                                       ret == 0 && ni_req->getserv ? servbuf : NULL,

                                       errno, h_errno);

        }

        case REQUEST_RES_QUERY:

        case REQUEST_RES_SEARCH: {

            int ret;

            HEADER answer[BUFSIZE/sizeof(HEADER) + 1];

            const res_request_t *res_req = &packet->res_request;

            const char *dname;

            assert(length >= sizeof(res_request_t));

            assert(length == sizeof(res_request_t) + res_req->dname_len);

            dname = (const char *) req + sizeof(res_request_t);

            if (req->type == REQUEST_RES_QUERY)

                ret = res_query(dname, res_req->class, res_req->type, (unsigned char *) answer, BUFSIZE);

            else

                ret = res_search(dname, res_req->class, res_req->type, (unsigned char *) answer, BUFSIZE);

            return send_res_reply(out_fd, req->id, (unsigned char *) answer, ret, errno, h_errno);

        }

        case REQUEST_TERMINATE:

            /* Quit */

            return -1;

        default:

            ;

    }

    return 0;

}

#ifndef HAVE_PTHREAD

static int process_worker(int in_fd, int out_fd) {

    int have_death_sig = 0;

    int good_fds[3];

    int ret = 1;

    const int ignore_sigs[] = {

        SIGINT,

        SIGHUP,

        SIGPIPE,

        SIGUSR1,

        SIGUSR2,

        -1

    };

    assert(in_fd > 2);

    assert(out_fd > 2);

    close(0);

    close(1);

    close(2);

    if (open("/dev/null", O_RDONLY) != 0)

        goto fail;

    if (open("/dev/null", O_WRONLY) != 1)

        goto fail;

    if (open("/dev/null", O_WRONLY) != 2)

        goto fail;

    if (chdir("/") < 0)

        goto fail;

    if (geteuid() == 0) {

        struct passwd *pw;

        int r;

        if ((pw = getpwnam("nobody"))) {

#ifdef HAVE_SETRESUID

            r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);

#elif HAVE_SETREUID

            r = setreuid(pw->pw_uid, pw->pw_uid);

#else

            if ((r = setuid(pw->pw_uid)) >= 0)

                r = seteuid(pw->pw_uid);

#endif

            if (r < 0)

                goto fail;

        }

    }

    if (reset_sigsv(ignore_sigs) < 0)

        goto fail;

    if (ignore_sigsv(ignore_sigs) < 0)

        goto fail;

    good_fds[0] = in_fd; good_fds[1] = out_fd; good_fds[2] = -1;

    if (close_allv(good_fds) < 0)

        goto fail;

#ifdef PR_SET_PDEATHSIG

    if (prctl(PR_SET_PDEATHSIG, SIGTERM) >= 0)

        have_death_sig = 1;

#endif

    if (!have_death_sig)

        fd_nonblock(in_fd);

    while (getppid() > 1) { /* if the parent PID is 1 our parent process died. */

        packet_t buf[BUFSIZE/sizeof(packet_t) + 1];

        ssize_t length;

        if (!have_death_sig) {

            fd_set fds;

            struct timeval tv = { 0, 500000 };

            FD_ZERO(&fds);

            FD_SET(in_fd, &fds);

            if (select(in_fd+1, &fds, NULL, NULL, &tv) < 0)

                break;

            if (getppid() == 1)

                break;

        }

        if ((length = recv(in_fd, buf, sizeof(buf), 0)) <= 0) {

            if (length < 0 &&

                (errno == EAGAIN || errno == EINTR))

                continue;

            break;

        }

        if (handle_request(out_fd, buf, (size_t) length) < 0)

            break;

    }

    ret = 0;

fail:

    send_died(out_fd);

    return ret;

}

#else

static void* thread_worker(void *p) {

    asyncns_t *asyncns = p;

    sigset_t fullset;

    /* No signals in this thread please */

    sigfillset(&fullset);

    pthread_sigmask(SIG_BLOCK, &fullset, NULL);

    while (!asyncns->dead) {

        packet_t buf[BUFSIZE/sizeof(packet_t) + 1];

        ssize_t length;

        if ((length = recv(asyncns->fds[REQUEST_RECV_FD], buf, sizeof(buf), 0)) <= 0) {

            if (length < 0 &&

                (errno == EAGAIN || errno == EINTR))

                continue;

            break;

        }

        if (asyncns->dead)

            break;

        if (handle_request(asyncns->fds[RESPONSE_SEND_FD], buf, (size_t) length) < 0)

            break;

    }

    send_died(asyncns->fds[RESPONSE_SEND_FD]);

    return NULL;

}

#endif

asyncns_t* asyncns_new(unsigned n_proc) {

    asyncns_t *asyncns = NULL;

    int i;

    assert(n_proc >= 1);

    if (n_proc > MAX_WORKERS)

        n_proc = MAX_WORKERS;

    if (!(asyncns = malloc(sizeof(asyncns_t)))) {

        errno = ENOMEM;

        goto fail;

    }

    asyncns->dead = 0;

    asyncns->valid_workers = 0;

    for (i = 0; i < MESSAGE_FD_MAX; i++)

        asyncns->fds[i] = -1;

    memset(asyncns->queries, 0, sizeof(asyncns->queries));

    if (socketpair(PF_UNIX, SOCK_DGRAM, 0, asyncns->fds) < 0 ||

        socketpair(PF_UNIX, SOCK_DGRAM, 0, asyncns->fds+2) < 0)

        goto fail;

    for (i = 0; i < MESSAGE_FD_MAX; i++)

        fd_cloexec(asyncns->fds[i]);

    for (asyncns->valid_workers = 0; asyncns->valid_workers < n_proc; asyncns->valid_workers++) {

#ifndef HAVE_PTHREAD

        if ((asyncns->workers[asyncns->valid_workers] = fork()) < 0)

            goto fail;

        else if (asyncns->workers[asyncns->valid_workers] == 0) {

            int ret;

            close(asyncns->fds[REQUEST_SEND_FD]);

            close(asyncns->fds[RESPONSE_RECV_FD]);

            ret = process_worker(asyncns->fds[REQUEST_RECV_FD], asyncns->fds[RESPONSE_SEND_FD]);

            close(asyncns->fds[REQUEST_RECV_FD]);

            close(asyncns->fds[RESPONSE_SEND_FD]);

            _exit(ret);

        }

#else

        int r;

        if ((r = pthread_create(&asyncns->workers[asyncns->valid_workers], NULL, thread_worker, asyncns)) != 0) {

            errno = r;

            goto fail;

        }

#endif

    }

#ifndef HAVE_PTHREAD

    close(asyncns->fds[REQUEST_RECV_FD]);

    close(asyncns->fds[RESPONSE_SEND_FD]);

    asyncns->fds[REQUEST_RECV_FD] = asyncns->fds[RESPONSE_SEND_FD] = -1;

#endif

    asyncns->current_index = asyncns->current_id = 0;

    asyncns->done_head = asyncns->done_tail = NULL;

    asyncns->n_queries = 0;

    fd_nonblock(asyncns->fds[RESPONSE_RECV_FD]);

    return asyncns;

fail:

    if (asyncns)

        asyncns_free(asyncns);

    return NULL;

}

void asyncns_free(asyncns_t *asyncns) {

    int i;

    int saved_errno = errno;

    unsigned p;

    assert(asyncns);

    asyncns->dead = 1;

    if (asyncns->fds[REQUEST_SEND_FD] >= 0) {

        rheader_t req;

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

        req.type = REQUEST_TERMINATE;

        req.length = sizeof(req);

        req.id = 0;

        /* Send one termination packet for each worker */

        for (p = 0; p < asyncns->valid_workers; p++)

            send(asyncns->fds[REQUEST_SEND_FD], &req, req.length, MSG_NOSIGNAL);

    }

    /* Now terminate them and wait until they are gone. */

    for (p = 0; p < asyncns->valid_workers; p++) {

#ifndef HAVE_PTHREAD

        kill(asyncns->workers[p], SIGTERM);

        for (;;) {

            if (waitpid(asyncns->workers[p], NULL, 0) >= 0 || errno != EINTR)

                break;

        }

#else

        for (;;) {

            if (pthread_join(asyncns->workers[p], NULL) != EINTR)

                break;

        }

#endif

    }

    /* Close all communication channels */

    for (i = 0; i < MESSAGE_FD_MAX; i++)

        if (asyncns->fds[i] >= 0)

            close(asyncns->fds[i]);

    for (p = 0; p < MAX_QUERIES; p++)