/*  authd, a lightweight IPv6/IPv4 inetd RFC 1413 ident protocol daemon

 *  Copyright 2004 by Red Hat, Inc.

 *

 *  THIS PROGRAM IS RELEASED UNDER THE GPL WITH THE ADDITIONAL EXEMPTION

 *  THAT COMPILING, LINKING, AND/OR USING OPENSSL IS ALLOWED.

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program 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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 *  02110-1301, USA.

 *

 *  Initial Author: Adrian Havill <havill@redhat.com>

 */

static const char RCSID[] = "$Revision: 1.18 $ $Date: 2004/07/28 16:04:05 $";

#include "config.h"

#define _GNU_SOURCE

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <locale.h>

#include <signal.h>

#include <stdarg.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <sys/utsname.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <getopt.h>

#include <langinfo.h>

#include <libintl.h>

#include <netdb.h>

#include <pwd.h>

#include <syslog.h>

#include <unistd.h>

#include <openssl/bio.h>

#include <openssl/buffer.h>

#include <openssl/evp.h>

#include <openssl/err.h>

#include <openssl/rand.h>

#if !defined NDEBUG

    #include <mcheck.h>

#endif

#define _(ascii_msgid) gettext(ascii_msgid)

static struct {

    int log_mask;

    int abrupt, help, hybrid, resolve, verbose, xerror; // longopt bool is pint

    bool debug, error, log, number, other, Version;

    char *codeset, *ident, *lang, *mapped, *os, *passwd, *username;

    char *Encrypt, *Noident;

    unsigned timeout, fn; unsigned long long multiquery;

} opt;

static void log_printf(int level, const char *s, ...) {

    if (opt.debug || level != LOG_DEBUG) {

        va_list ap;

        if (s == NULL || *s == '\0') {

            s = strerror(errno);

            assert(strchr(s, '%') == NULL);

        }

        if (opt.log) {

            va_start(ap, s);

            vsyslog(level, s, ap);

            va_end(ap);

        }

        va_start(ap, s);

        if (vfprintf(level == LOG_INFO ? stdout : stderr, s, ap) < 0) {

            perror(program_invocation_name);

            level = INT_MIN;

        }

        va_end(ap);

    }

    if (level <= LOG_ERR) exit(EXIT_FAILURE);

}

#define debug(...)        log_printf(LOG_DEBUG, __VA_ARGS__)

#define show(...)         log_printf(LOG_INFO, __VA_ARGS__)

#define log_notice(...)   log_printf(LOG_NOTICE, __VA_ARGS__)

#define log_warning(...)  log_printf(LOG_WARNING, __VA_ARGS__)

#define handle_error(...) log_printf(LOG_ERR, __VA_ARGS__)

#if !defined NDEBUG

static const void *const LAST_VA_ARG = "FIXME"; // debugging sentinel

#endif

static char *vstrdup(const char *s, ...) {

    va_list ap; char *dup;

    assert(s != LAST_VA_ARG);

    va_start(ap, s);

    while (s == NULL || *s == '\0') {

        s = va_arg(ap, const char *);

        assert(s != LAST_VA_ARG);

    }

    va_end(ap);

    if ((dup = strdup(s)) == NULL) handle_error(NULL);

    return dup;

}

#if !defined NDEBUG

    #define vstrdup(s, ...) vstrdup((s) ,##__VA_ARGS__ ,LAST_VA_ARG)

#endif

static void show_help(void) {

    show(_("%s [options]... [request]...\n"), program_invocation_short_name);

    show(_(" -d\t\t\tOutput debug messages\n"));

    show(_(" -E[cipher]\t\tEncrypt username using [%s]\n"), DFL_CIPHER);

    show(_(" -e\t\t\tSend UNKNOWN-ERROR for common error messages\n"));

    show(_(" -l[mask]\t\tLog to syslog, [mask] for priority levels\n"));

    show(_(" -m[reps]\t\tAllow at most [unlimited] requests/connection\n"));

    show(_(" -N[basename]\t\tHide users with ~/[%s] file\n"), DFL_NO_IDENT);

    show(_(" -n\t\t\tSend uid number instead of username\n"));

    show(_(" -o\t\t\tSend OTHER instead of the operating system\n"));

    show(_(" -t[secs]\t\tTimeout request after [%u] seconds\n"), DFL_T_O);

    show(_(" -V\t\t\tPrint program and version information\n"));

    show(_(" --abrupt\t\tDisconnect without displaying error msgs\n"));

    show(_(" --codeset=rfc1340\tSend [charset] if reply is not ASCII\n"));

    show(_(" --fn[=fields]\t\tUse [all] gecos fields instead of username\n"));

    show(_(" --hybrid\t\tUse hybrid notation (ex. ::127.0.0.1) for IPv6\n"));

    show(_(" --ident[=basename]\tHide users with no ~/[%s]\n"), DFL_IDENT);

    show(_(" --lang=lc\t\tLocalize messages, charsets, & time to [locale]\n"));

    show(_(" --mapped=ipv6\t\tMap addresses with same top 96 bits to IPv4\n"));

    show(_(" --os[=rfc1340]\t\tUse [uname], not %s, as OS name\n"), DFL_OS);

    show(_(" --passwd=pathname\tUse line 1 of [%s] for crypto\n"), DFL_PASSWD);

    show(_(" --resolve\t\tUse host and service names if available\n"));

    show(_(" --username[=login]\tUse [%s] as username\n"), DFL_USERNAME);

    show(_(" --verbose\t\tAdd real uid, addresses/ports, & timestamps\n"));

    show(_(" --xerror\t\tSend more helpful error messages for rare errors\n"));

}

static void show_version(void) {

    show("%s-%s:\n\t%s\n\t%s\n", PACKAGE, VERSION, RCSID, CONTACT);

}

static bool is_print_ascii(const char *s) {

    assert(s != NULL);

    while (*s != '\0')

        if (!isascii(*s) || iscntrl(*s)) return false;

        else s++;

    return true;

}

#define is_in_range(lo,x,hi) ((lo) <= (x) && (x) <= (hi))

static bool is_rfc1413_token(const char *s) {

    assert(s != NULL);

    if (!is_print_ascii(s) || strchr(s, ':') != NULL) return false;

    return is_in_range((size_t) 1, strlen(s), (size_t) 64);

}

static bool is_bad_strto(const char *s, const char *endptr) {

    if (errno == ERANGE || errno == EINVAL) return true;

    return endptr == s || (*endptr != '\0' && !isspace(*endptr));

}

static const int HEX_DIG = 2;           // two digits in 8-bit base 16 octet

static const size_t HEX_LEN_MAX = 32;   // strlen() of /proc/net/tcp6 address

static char *created_addr_hex(const unsigned char *addr, size_t addr_size) {

    char *addr_hex;

    size_t addr_hex_size = addr_size * HEX_DIG + sizeof '\0';

    if ((addr_hex = calloc(addr_hex_size, sizeof(char))) != NULL) {

        size_t z = addr_size; char *p = addr_hex;

        while (z != 0) {

            int n = snprintf(p, addr_hex_size, "%.*hhX", HEX_DIG, addr[--z]);

            assert(n >= 0 && (size_t) n < addr_hex_size);

            addr_hex_size -= (size_t) n; p += (size_t) n;

        }

    }

    return addr_hex;

}

static char *created_pton_hex(const char *prefix) {

    struct in6_addr addr; const size_t SIZE = sizeof(addr.s6_addr);

    assert(prefix != NULL);

    if (inet_pton(AF_INET6, prefix, &addr) <= 0) return NULL;

    return created_addr_hex((const void *) addr.s6_addr, SIZE);

}

static void create_opt(int argc, char *argv[]) {

    enum { PRE_FIRST_LONGOPT = UCHAR_MAX,       // no short opt value overlap

        CODESET_LONGOPT, IDENT_LONGOPT, FN_LONGOPT, LANG_LONGOPT,

        MAPPED_LONGOPT, OS_LONGOPT, PASSWD_LONGOPT, USERNAME_LONGOPT

    };

    int c, i;

    const char *const IPV4_HEX_0 = "00000000";

    const char *const S_FMT = _("%s: invalid argument to --%s: %s\n");

    const char *const C_FMT = _("%s: invalid argument to -%c: %s\n");

    const char *const SHORT_OPTS = "dE::ehl::m::N::not::V"; // pidentd compat

    const struct option LONG_OPTS[] = {

        { "abrupt",   no_argument,       &opt.abrupt,  true             },

        { "codeset",  required_argument, NULL,         CODESET_LONGOPT  },

        { "fn",       optional_argument, NULL,         FN_LONGOPT       },

        { "help",     no_argument,       NULL,         'h'              },

        { "hybrid",   no_argument,       &opt.hybrid,  true             },

        { "ident",    optional_argument, NULL,         IDENT_LONGOPT    },

        { "lang",     required_argument, NULL,         LANG_LONGOPT     },

        { "mapped",   required_argument, NULL,         MAPPED_LONGOPT   },

        { "os",       optional_argument, NULL,         OS_LONGOPT       },

        { "passwd",   required_argument, NULL,         PASSWD_LONGOPT   },

        { "resolve",  no_argument,       &opt.resolve, true             },

        { "usage",    no_argument,       NULL,         'h'              },

        { "username", optional_argument, NULL,         USERNAME_LONGOPT },

        { "verbose",  no_argument,       &opt.verbose, true             },

        { "xerror",   no_argument,       &opt.xerror,  true             },

        { 0,          0,                 0,            0                }

    };

    assert(argc > 0 && argv != NULL);

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

    opt.passwd = vstrdup(DFL_PASSWD);

    if ((opt.mapped = calloc(HEX_LEN_MAX + sizeof '\0', sizeof(char))) == NULL)

        handle_error(NULL);

    memset(opt.mapped, '0', HEX_LEN_MAX);

    opt.multiquery = 1;

    opt.timeout = UINT_MAX;

    while ((c = getopt_long(argc, argv, SHORT_OPTS, LONG_OPTS, &i)) != -1) {

        switch (c) {

            struct utsname os;

            unsigned long lu; char *endptr, *lc;

            case 'd': opt.debug = true; break;

            case 'E':

                free(opt.Encrypt); opt.Encrypt = vstrdup(optarg, DFL_CIPHER);

                break;

            case 'e': opt.error = true; break;

            case 'h': opt.help = true; break;

            case 'l':

                if (optarg != NULL) {

                    lu = strtoul(optarg, &endptr, 0);

                    if (lu > UINT_MAX || is_bad_strto(optarg, endptr))

                        handle_error(C_FMT, *argv, c, optarg);

                    else opt.log_mask = (int) lu;

                    setlogmask(opt.log_mask);

                }

                opt.log = true;

                break;

            case 'm':

                if (optarg != NULL) {

                    opt.multiquery = strtoull(optarg, &endptr, 10);

                    if (is_bad_strto(optarg, endptr))

                        handle_error(C_FMT, *argv, c, optarg);

                }

                else opt.multiquery = ULLONG_MAX;

                break;

            case 'n': opt.number = true; break;

            case 'N':

                free(opt.Noident); opt.Noident = vstrdup(optarg, DFL_NO_IDENT);

                break;

            case 'o': opt.other = true; break;

            case 't':

                lu = optarg == NULL ? DFL_T_O : strtoul(optarg, &endptr, 10);

                if (lu > UINT_MAX || is_bad_strto(optarg, endptr))

                    handle_error(C_FMT, *argv, c, optarg);

                else if (lu < 30) {

                    log_notice(_("Timeout's too low; Raising to 30.\n"));

                    lu = 30;

                }

                else if (lu != 0 && !is_in_range(60, lu, 180)) 

                    log_notice(_("Timeout should be from 60..180 seconds.\n"));

                opt.timeout = (unsigned) lu;

                break;

            case 'V': opt.Version = true; break;

            case CODESET_LONGOPT:

                if (!is_rfc1413_token(optarg))

                    handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                free(opt.codeset); opt.codeset = vstrdup(optarg);

                break;

            case FN_LONGOPT:

                if (optarg != NULL) {

                    lu = strtoul(optarg, &endptr, 10);

                    if (lu > UINT_MAX || is_bad_strto(optarg, endptr))

                        handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                    else opt.fn = (unsigned) lu;

                }

                else opt.fn = UINT_MAX;

                break;

            case IDENT_LONGOPT:

                free(opt.ident); opt.ident = vstrdup(optarg, DFL_IDENT);

                break;

            case LANG_LONGOPT:

                lc = strlen(optarg) == 0 ? NULL : setlocale(LC_ALL, optarg);

                if (lc == NULL)

                    handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                else {

                    free(opt.lang); opt.lang = vstrdup(lc);

                    debug("LC_ALL = %s\n", opt.lang);

                }

                break;

            case MAPPED_LONGOPT:

                free(opt.mapped);

                if ((opt.mapped = created_pton_hex(optarg)) == NULL)

                    handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                if (strncmp(opt.mapped, IPV4_HEX_0, strlen(IPV4_HEX_0)) != 0)

                    log_notice(_("Mapped lower 32 bits not 0; ignoring.\n"));

                debug("prefix map    =%s/%s\n", IPV4_HEX_0, opt.mapped + 8);

                break;

            case OS_LONGOPT:

                if (optarg == NULL && uname(&os) != 0) handle_error(NULL);

                free(opt.os); opt.os = vstrdup(optarg, os.sysname);

                if (!is_rfc1413_token(opt.os))

                    handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                break;

            case PASSWD_LONGOPT:

                free(opt.passwd); opt.passwd = vstrdup(optarg, DFL_PASSWD);

                if (strlen(opt.passwd) == 0)

                    handle_error(S_FMT, *argv, LONG_OPTS[i].name, optarg);

                break;

            case USERNAME_LONGOPT:

                free(opt.username);

                opt.username = vstrdup(optarg, DFL_USERNAME);

                break;

            default:

                assert(0 == c); // GNU extensions ('\1' and ':') should be off

                break;

            case '?': exit(EXIT_FAILURE);

        }

    }

    if (optind < argc)

        opt.timeout = 0;        // don't get client input if request(s) in cmd

}

static const char *const DELIM = ",: \t\r\n\v\f";

static unsigned long long get_tok_ullong(char *s, unsigned base) {

    unsigned long long ull = ULLONG_MAX;

    assert(base <= 36);

    if ((s = strtok(s, DELIM)) != NULL) {

        char *endptr;

        ull = strtoull(s, &endptr, (int) base);

        if ((errno == ERANGE && ull == ULLONG_MAX) || is_bad_strto(s, endptr))

            errno = EINVAL;

    }

    else errno = EINVAL;

    return ull;

}

static unsigned long get_tok_uint(char *s, unsigned base) {

    unsigned long ul = ULONG_MAX;

    assert(base <= 36);

    if ((s = strtok(s, DELIM)) != NULL) {

        char *endptr;

        ul = strtoul(s, &endptr, (int) base);

        if (ul > UINT_MAX || is_bad_strto(s, endptr))

            errno = EINVAL;

    }

    else errno = EINVAL;

    return ul;

}

static long get_tok_int(char *s, unsigned base) {

    long l = LONG_MAX;

    assert(base <= 36);

    if ((s = strtok(s, DELIM)) != NULL) {

        char *endptr;

        l = strtol(s, &endptr, (int) base);

        if (l > INT_MAX || is_bad_strto(s, endptr))

            errno = EINVAL;

    }

    else errno = EINVAL;

    return l;

}

static void destroy_opt(void) {

    free(opt.codeset); free(opt.Encrypt); free(opt.ident); free(opt.lang);

    free(opt.Noident); free(opt.os); free(opt.passwd); free(opt.mapped);

    free(opt.username);

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

}

typedef struct {

    unsigned long lport, rport;

    char *laddr, *raddr;

} request_t;

typedef int (*getsockaddr_t)(int, struct sockaddr *, socklen_t *);

static char *created_connected_addr(int sockfd, getsockaddr_t getXXXXname) {

    struct sockaddr_storage name; socklen_t namelen = sizeof(name);

    char *addr_hex = NULL;

    if (getXXXXname(sockfd, (struct sockaddr *) &name, &namelen) == 0) {

        size_t addr_size = 0;

        const unsigned char *addr = NULL; 

        switch (name.ss_family) {

            struct sockaddr_in *sin; struct sockaddr_in6 *sin6;

        case AF_INET:

            sin = (struct sockaddr_in *) &nam;;

            addr_size = sizeof(sin->sin_addr.s_addr);

            addr = (unsigned char *) &sin->sin_addr.s_addr;

            break;

        case AF_INET6:

            sin6 = (struct sockaddr_in6 *) &nam;;

            addr_size = sizeof(sin6->sin6_addr.s6_addr);

            addr = (unsigned char *) sin6->sin6_addr.s6_addr;

            break;

        default:

            errno = EAFNOSUPPORT;

        }

        addr_hex = created_addr_hex(addr, addr_size);

    }

    else if (errno == ENOTSOCK)

        errno = 0;      // no error if invoked from cmdline

    return addr_hex;

}

static request_t created_request(int argc, char *argv[]) {

    request_t in;

    char *line = NULL; size_t n = 0;

    assert(argv != NULL && argc >= 1);

    if (optind >= argc) {

        if (fflush_unlocked(stdout) == EOF) handle_error(NULL);

        in.laddr = created_connected_addr(STDIN_FILENO, getsockname);

        in.raddr = created_connected_addr(STDIN_FILENO, getpeername);

        if (opt.timeout != UINT_MAX)

            alarm(opt.timeout);

        if (getline(&line, &n, stdin) == (ssize_t) -1) {

            if (feof_unlocked(stdin)) {

                free(line);

                exit(EXIT_SUCCESS);

            }

            assert(ferror(stdin));

            handle_error(NULL);

        }

        alarm(0);

    }

    else {

        line = vstrdup(argv[(size_t) optind++]);

        in.laddr = in.raddr = NULL;

    }

    in.lport = get_tok_uint(line, 10); in.rport = get_tok_uint(NULL, 10);

    debug("local_address =%s:%04lX\n", in.laddr, in.lport);

    debug("rem_address   =%s:%04lX\n", in.raddr, in.rport);

    free(line);

    return in;

}

static char *created_hostname(const char *node) {

    char *s;

    struct addrinfo *res, hints = { ai_flags: AI_CANONNAME };

    assert(node != NULL && *node != '\0');

    if (opt.resolve && getaddrinfo(node, NULL, &hints, &res) == 0) {

        s = vstrdup(res->ai_canonname, node); freeaddrinfo(res);

    }

    else s = vstrdup(node);

    return s;

}

static const unsigned long PORT_MIN = 1, PORT_MAX = 65535;

static char *created_servicename(unsigned long port) {

    char *s;

    const char *const PROTO = "tcp", *const PORT_FMT = "%lu";

    const int NS_PORT = (int) htons((uint16_t) port);

    struct servent *res = opt.resolve ? getservbyport(NS_PORT, PROTO) : NULL;

    assert(is_in_range(PORT_MIN, port, PORT_MAX));

    if (res == NULL || res->s_name == NULL || *res->s_name == '\0') {

        if (asprintf(&s, PORT_FMT, port) < 0) handle_error(NULL);

    }

    else s = vstrdup(res->s_name);

    return s;

}

static char *get_created_tok_addr(const char *peer_addr_hex) {

    const char *const IPV6_0 = ":0000", *const IPV6_0_RUN = "::";

    const size_t IPV6_SIZE_MAX = INET6_ADDRSTRLEN + sizeof '\0';

    const size_t IPV6_0_RUN_LEN = strlen(IPV6_0_RUN);

    char *addr = calloc(sizeof ':' + IPV6_SIZE_MAX, sizeof(char));

    char *addr_hex, *p = addr, *q, *zero = NULL; size_t zero_n = 0;

    if (addr != NULL) {

        if ((addr_hex = strtok(NULL, DELIM)) != NULL) {

            size_t z = strlen(addr_hex); const bool IS_IPV6 = z > 8;

            bool is_16_bits = true;

            if (peer_addr_hex != NULL) {

                char peer_128[HEX_LEN_MAX + sizeof '\0'];

                char host_128[HEX_LEN_MAX + sizeof '\0'];

                assert(opt.mapped != NULL);

                strcpy(peer_128, opt.mapped); strcpy(host_128, opt.mapped);

                /*

                   If mapping IPV4 to IPV6 space is enabled,

                   take only last 4 numbers of IPV6

                */

                if(opt.mapped[0]) {

                  strncpy(host_128, addr_hex+z-8, 8);

                  strncpy(peer_128, peer_addr_hex, 8);

                } else {

                  strncpy(host_128, addr_hex, z);

                  strncpy(peer_128, peer_addr_hex, strlen(peer_addr_hex));

                }

                if (strcmp(peer_128, host_128) != 0) return addr;

            }

            // hex addr must have even number of digits

            if ((int) z & 1) {

                free(addr);

                errno = EINVAL;

                return NULL;

            }

            while (z > 1) {

                unsigned long ul; char *endptr;

                const bool IS_IPV4 = (opt.hybrid && z < 9) || !IS_IPV6;

                addr_hex[z] = '\0'; z -= HEX_DIG;

                ul = strtoul(addr_hex + z, &endptr, 16);

                if (is_bad_strto(addr_hex + z, endptr)) {

                    free(addr); 

                    errno = EINVAL;

                    return NULL;

                }

	        if ((!IS_IPV4 || 6 == z) && is_16_bits)

                    *p++ = ':';

                if (IS_IPV4)

                    p += sprintf(p, "%lu", ul);

                else p += sprintf(p, "%.*lX", HEX_DIG, ul);

                if (IS_IPV4 && z != 0)

                    *p++ = '.';

                is_16_bits = !is_16_bits;

            }

        }

        // compress 16-bit runs of zeros

        for (p = strstr(addr, IPV6_0); p != NULL; p = strstr(q, IPV6_0)) {

            size_t count = 0; const size_t IPV6_0_LEN = strlen(IPV6_0);

            for (q = p; strncmp(q, IPV6_0, IPV6_0_LEN) == 0; q += IPV6_0_LEN)

                count += IPV6_0_LEN;

            if (count > zero_n) {

                zero_n = count; zero = p;

            }

        }

        if (zero_n >= IPV6_0_RUN_LEN) {

            memcpy(zero, IPV6_0_RUN, IPV6_0_RUN_LEN);

            zero += IPV6_0_RUN_LEN; zero_n -= IPV6_0_RUN_LEN;

            if (zero[zero_n] == ':')

                zero_n++;

            memmove(zero, zero + zero_n, strlen(zero + zero_n) + 1);

        }

        // compress four digit hex sequences by removing leading zeros

        while ((zero = strstr(addr, ":0")) != NULL)

            if (strchr(++zero, ':') == NULL) break;

            else memmove(zero, zero + 1, strlen(zero));

        if (addr[1] != ':')

            memmove(addr, addr + 1, IPV6_SIZE_MAX);  // rm ':' prefix

    }

    return addr;

}

static bool is_regular_file(const char *dir, const char *name) {

    bool is_existing = false;

    assert(dir != NULL);

    if (name != NULL) {

        struct stat st;

        if (stat(dir, &st) == 0 && S_ISDIR(st.st_mode)) {

            char *s;

            const char *const PATHNAME_FMT = "%s/%s";

            if (*name != '\0') {

                if (asprintf(&s, PATHNAME_FMT, dir, name) < 0) return false;

                is_existing = stat(s, &st) == 0 && S_ISREG(st.st_mode);

                free(s);

            }

            else errno = EISDIR;

        }

        else errno = ENOTDIR;

        if (errno == ENOENT)

            errno = 0;  // don't report X-ERRNO-%d

    }

    return is_existing;

}

typedef struct {

    bool error;

    unsigned lport, rport; char *os, *enc, *s;

} reply_t;

static const size_t USERID_MAX_LEN = 512; // as per RFC1413 <octet-string>

static const char *const TEXT_READ_MODE = "r"; // passphrase, /proc plaintext

static bool get_info(reply_t *out, request_t in, const char *tcpname) {

    //unsigned long lport, rport, uid, status; FILE *stream;

    unsigned long lport, rport, status; FILE *stream;

    long uid;

    const unsigned long ESTABLISHED = 0x01;

    unsigned lineno = 0;

    char *laddr = NULL, *raddr = NULL;

    bool is_port_pair_found = false;

    char *created_verbose(const char *name, unsigned long id) {

        size_t n; time_t tod;

        char *s, when[USERID_MAX_LEN], *host1, *port1, *host2, *port2;

        const char *const UTC_FMT = "%FT%TZ", *const TZ_FMT = "(%a %EX %z/%Z)";

        const char *const VERBOSE_FMT = "%s:%lu,%s,%s|%s,%s|%s";

        if (time(&tod) == (time_t) -1) handle_error(NULL);

        n = strftime(when, sizeof(when), UTC_FMT, gmtime(&tod));

        strftime(when + n, sizeof(when) - n, TZ_FMT, localtime(&tod));

        host1 = created_hostname(laddr); port1 = created_servicename(lport);

        host2 = created_hostname(raddr); port2 = created_servicename(rport);

        asprintf(&s, VERBOSE_FMT, name, id, when, host1, port1, host2, port2);

        free(host1); free(port1); free(host2); free(port2);

        return s;

    }

    assert(out != NULL);

    if (tcpname == NULL) return false;

    if ((stream = fopen(tcpname, TEXT_READ_MODE)) == NULL) {

        // some systems won't have tcp6 (and rarely, plain IPv4 tcp) files in

        // /proc/net. The absence of either file isn't an error; although

        // the lack of both prevents authd from looking up anything

        if (errno == ENOENT) {

            if (opt.log) log_notice("%s: %s\n", tcpname, strerror(errno));

            errno = 0;

        }

        else out->error = true;

    }

    else for (;;) {

        unsigned long sl, inode;

        uid_t euid;

        char line[PROC_MAX_LEN], tmp[PROC_MAX_LEN];

        // FIXME: setting the buffer to be larger than normal is done to

        // lessen (but not eliminate) the chance of the proc file changing

        // while in the middle of reading it

        if (0 == lineno) {

            const size_t SIZE = (size_t) (BUFSIZ * PROC_SIZE);

            if (setvbuf(stream, NULL, _IOFBF, SIZE) != 0) {

                out->error = true; break;

            }

        }

        if (fgets_unlocked(line, (int) PROC_MAX_LEN, stream) == NULL) {

            if (ferror_unlocked(stream))

                out->error = true;

            assert(feof(stream));

            break;

        }

        else lineno++;

        // first line of /proc/net/tcp* is a header that looks similar to:

        //    sl local rem st tx rx tr tm->when retrnsmt   uid  timeout inode

        if (1 == lineno) continue;

        // sample line from tcp (tcp6 just has a bigger ip address):

        //    0: 00000000:800B 00000000:0000 0A 0000:0000 00:0000 0000 0000 ...

        sl = get_tok_uint(strcpy(tmp, line), 10); // sl (base 10 uint)

        laddr = get_created_tok_addr(in.laddr);   // local (little endian hex)

        lport = get_tok_uint(NULL, 16);           // ... local port

        raddr = get_created_tok_addr(in.raddr);   // remote (little endian hex)

        rport = get_tok_uint(NULL, 16);           // ... remote port

        status = get_tok_uint(NULL, 16);          // status (01 = ESTABLISHED)

        (void) get_tok_uint(NULL, 16);            // tx_queue

        (void) get_tok_uint(NULL, 16);            // rx_queue

        (void) get_tok_uint(NULL, 16);            // tr (boolean)

        (void) get_tok_ullong(NULL, 16);            // tm->when (unit: jiffies)

        strtok(NULL, DELIM);                      // retrnsmt

        //uid = get_tok_uint(NULL, 10);             // uid (base 10 uint)

        uid = get_tok_int(NULL, 10);             // uid (base 10 int)

        strtok(NULL, DELIM);                      // timeout

        inode = get_tok_uint(NULL, 10);           // inode (base 10 uint)

        if (errno == EINVAL) {

            // format of /proc/net/tcp* has changed or it's a bogus file

            debug("%s:%u: %s", tcpname, lineno, line);  // XXX: NL terminated?

            out->error = true; errno = 0;

            out->s = opt.xerror ? vstrdup("X-PROC") : NULL; break;

        }

        else if (errno != 0) {

            // most likely an out-of-memory error

            out->error = true; break;

        }

        else if (*laddr == '\0' || *raddr == '\0') {

            // host address doesn't match peer address, so skip it

            free(laddr); free(raddr); laddr = raddr = NULL; continue;

        }

        else euid = (uid_t) uid;

        if (lport == in.lport && rport == in.rport && status == ESTABLISHED) {

            struct passwd *pwd = getpwuid(euid);

            is_port_pair_found = true;

            debug("%-14s=sl:%lu uid:%lu inode:%lu\n", tcpname, sl, uid, inode);

            if (opt.username != NULL) {

                if ((pwd = getpwnam(opt.username)) == NULL) {

                    out->error = true;

                    out->s = opt.xerror ? vstrdup("X-NAME") : NULL; break;

                }

                else euid = pwd->pw_uid;

            }

            if (pwd == NULL) { // passwd db doesn't have uid in /proc/net/tcp*

                out->error = true;

                out->s = opt.xerror ? vstrdup("X-UID") : NULL; break;

            }

            else {

                bool hidden = opt.ident != NULL;

                if (is_regular_file(pwd->pw_dir, opt.ident))

                    hidden = false;

                if (is_regular_file(pwd->pw_dir, opt.Noident))

                    hidden = true;

                if (errno) {

                    out->error = true;

                    out->s = opt.xerror ? vstrdup("X-FILE") : NULL;

                    break;

                }

                else if (hidden) {

                    out->error = true; out->s = vstrdup("HIDDEN-USER"); break;

                }

                out->s = vstrdup(pwd->pw_name);

                if (opt.number) {

                    const char *const UID_FMT = "%lu";

                    free(out->s);

                    if (asprintf(&out->s, UID_FMT, (unsigned long) euid) < 0) {

                        out->error = true; break;

                    }

                }

                if (opt.fn != 0 && *pwd->pw_gecos != '\0') {

                    char *s = vstrdup(pwd->pw_gecos);

                    size_t n = 0;

                    // gecos field usually just has 1 field, the full name--

                    // but sometimes the user's office, office phone and home

                    // phone will be in csv format

                    for (unsigned u = 0; u < opt.fn && s[n] != '\0'; u++, n++)

                        n += strcspn(s + n, ",");

                    s[--n] = '\0';

                    if (opt.number) {

                        n = strcspn(s, ",");

                        memmove(s, s + n, strlen(s + n) + 1);

                        n = strlen(out->s) + strlen(s);

                        if ((out->s = realloc(out->s, ++n)) == NULL) {

                            out->error = true; break;

                        }

                        strcat(out->s, s); free(s);

                    }

                    else { free(out->s); out->s = s; }

                }

            }

            if (opt.verbose && !out->error) {

                char *brief = out->s;

                if ((out->s = created_verbose(brief, uid)) == NULL)

                    out->error = true;

                else free(brief);

            }

            break;

        }

        else { free(laddr); free(raddr); laddr = raddr = NULL; }

    }

    free(laddr); free(raddr);

    if (stream != NULL && fclose(stream) == EOF) {

        out->error = true; out->s = NULL;

    }

    return is_port_pair_found;

}

typedef struct {

    const EVP_CIPHER *cipher; BIO *writer; BUF_MEM *buffer;

    unsigned char *key, *iv, salt[PKCS5_SALT_LEN];

} crypto_t;

static bool initialize_crypto(crypto_t *x, const char *filename) {

    struct stat file;

    bool is_initialized = false;

    assert(filename != NULL && x != NULL);

    if (stat(filename, &file) == 0) {

        FILE *stream; ssize_t len;

        const EVP_MD *const HASH = EVP_md5();   // openssl compat: enc -pass

        const size_t KEY_SIZE = EVP_CIPHER_key_length(x->cipher);

        const size_t IV_SIZE = EVP_CIPHER_iv_length(x->cipher);

        unsigned char *pass = NULL; size_t z = 0;

        if (!S_ISREG(file.st_mode)) return false;       // no dirs, devs, etc.

        if  (file.st_mode & (S_IROTH | S_IWOTH)) return false;  // no ------rw-

        if ((x->key = malloc(KEY_SIZE)) == NULL) return false;

        if ((x->iv = malloc(IV_SIZE)) == NULL) return false;

        if ((stream = fopen(filename, TEXT_READ_MODE)) == NULL) return false;

        if ((len = getline(&pass, &z, stream)) == (ssize_t) -1) return false;

        if (fclose(stream) == EOF) return false;

        if (len > 0 && pass[(size_t) (len - 1)] == '\n')

            pass[(size_t) --len] = '\0';

        if (RAND_pseudo_bytes(x->salt, sizeof(x->salt)) <= 0) return false;

        EVP_BytesToKey(x->cipher, HASH, x->salt, pass, len, 1, x->key, x->iv);

        memset(pass, 0, len);                           // XXX: crypto erase

        free(pass);

        is_initialized = true;

        if (opt.debug) {

            char line[80] = { '\0' }, *p = line;

            int n; size_t size = sizeof(line);

            n = snprintf(p, size, "salt[%2zu bytes]=", sizeof(x->salt));

            assert(n >= 0);

            for (z = 0; z < sizeof(x->salt) && n < (int) size; z++) {

                p += n; size -= n;

                n = snprintf(p, size, "%.*hhX", CHAR_BIT / 4, x->salt[z]);

                assert(n >= 0);

            }

            debug("%s\n", line); p = line; size = sizeof(line);

            n = snprintf(p, size, "key[%4d bits]=", (int) KEY_SIZE * CHAR_BIT);

            assert(n >= 0);

            for (z = 0; z < KEY_SIZE && n < (int) size; z++) {

                p += n; size -= n;

                n = snprintf(p, size, "%.*hhX", CHAR_BIT / 4, x->key[z]);

                assert(n >= 0);

            }

            debug("%s\n", line); p = line; size = sizeof(line);

            n = snprintf(p, size, "iv[%5d bits]=", (int) IV_SIZE * CHAR_BIT);

            assert(n >= 0);

            for (z = 0; z < IV_SIZE && n < (int) size; z++) {

                p += n; size -= n;

                n = snprintf(p, size, "%.*hhX", CHAR_BIT / 4, x->iv[z]);

                assert(n >= 0);

            }

            debug("%s\n", line);

            memset(line, 0, sizeof(line));              // XXX: crypto erase

        }

    }

    return is_initialized;

}

static char *created_ciphertext_b64(const char *s) {

    BIO *encoder; char *b64;

    const char *const MAGIC = "Salted__";       // openssl compat: enc -salt

    const char *const NL = "\n";                // is strcat()ed to plaintext

    crypto_t x = { cipher: NULL };

    assert(s != NULL);

    OpenSSL_add_all_ciphers();

    if ((x.cipher = EVP_get_cipherbyname(opt.Encrypt)) == NULL) return NULL;

    debug("cipher name   =%s\n", EVP_CIPHER_name(x.cipher));

    debug("cipher block  =%d bytes\n", EVP_CIPHER_block_size(x.cipher));

    switch (EVP_CIPHER_mode(x.cipher)) {

    case EVP_CIPH_ECB_MODE: debug("cipher mode   =%s\n", "ECB"); break;

    case EVP_CIPH_CBC_MODE: debug("cipher mode   =%s\n", "CBC"); break;

    case EVP_CIPH_CFB_MODE: debug("cipher mode   =%s\n", "CFB"); break;