path: root/whois.c

/*
 * Copyright (C) Marco d'Itri <md@linux.it>.
 *
 * 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.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

/* for AI_IDN */
#define _GNU_SOURCE

/* System library */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include "config.h"
#include <string.h>
#include <ctype.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#ifdef HAVE_GETOPT_LONG
#include <getopt.h>
#endif
#ifdef HAVE_REGEXEC
#include <regex.h>
#endif
#ifdef HAVE_LIBIDN2
#include <idn2.h>
#elif defined HAVE_LIBIDN
#include <idna.h>
#endif

/* Application-specific */
#include "version.h"
#include "data.h"
#include "whois.h"
#include "utils.h"

#ifdef HAVE_ICONV
#include "simple_recode.h"
#else
#define recode_fputs(a, b) fputs(a, b)
#endif

/* hack */
#define malloc(s) NOFAIL(malloc(s))
#define realloc(p, s) NOFAIL(realloc(p, s))
#ifdef strdup
#undef strdup
#define strdup(s) NOFAIL(__strdup(s))
#else
#define strdup(s) NOFAIL(strdup(s))
#endif

/* Global variables */
int sockfd, verb = 0, no_recursion = 0;

#ifdef ALWAYS_HIDE_DISCL
int hide_discl = HIDE_NOT_STARTED;
#else
int hide_discl = HIDE_DISABLED;
#endif

const char *client_tag = IDSTRING;

#ifndef HAVE_GETOPT_LONG
extern char *optarg;
extern int optind;
#endif

int main(int argc, char *argv[])
{
#ifdef HAVE_GETOPT_LONG
    const struct option longopts[] = {
	/* program flags */
	{"version",		no_argument,		NULL, 1  },
	{"verbose",		no_argument,		NULL, 2  },
	{"help",		no_argument,		NULL, 3  },
	{"no-recursion",	no_argument,		NULL, 4  },
	{"server",		required_argument,	NULL, 'h'},
	{"host",		required_argument,	NULL, 'h'},
	{"port",		required_argument,	NULL, 'p'},
	/* long RIPE flags */
	{"exact",		required_argument,	NULL, 'x'},
	{"all-more",		required_argument,	NULL, 'M'},
	{"one-more",		required_argument,	NULL, 'm'},
	{"all-less",		required_argument,	NULL, 'L'},
	{"one-less",		required_argument,	NULL, 'l'},
	{"reverse-domain",	required_argument,	NULL, 'd'},
	{"irt",			required_argument,	NULL, 'c'},
	{"abuse-contact",	no_argument,		NULL, 'b'},
	{"brief",		no_argument,		NULL, 'F'},
	{"primary-keys",	no_argument,		NULL, 'K'},
	{"persistent-connection", no_argument,		NULL, 'k'},
	{"no-referenced",	no_argument,		NULL, 'r'},
	{"no-filtering",	no_argument,		NULL, 'B'},
	{"no-grouping",		no_argument,		NULL, 'G'},
	{"select-types",	required_argument,	NULL, 'T'},
	{"all-sources",		no_argument,		NULL, 'a'},
	{"sources",		required_argument,	NULL, 's'},
	{"types",		no_argument,		NULL, 12 }, /* -q */
	{"ripe-version",	no_argument,		NULL, 12 }, /* -q */
	{"list-sources",	no_argument,		NULL, 12 }, /* -q */
	{"template",		required_argument,	NULL, 't'},
	{"ripe-verbose",	required_argument,	NULL, 'v'},
	/* long RIPE flags with no short equivalent */
	{"list-versions",	no_argument,		NULL, 10 },
	{"diff-versions",	required_argument,	NULL, 11 },
	{"show-version",	required_argument,	NULL, 11 },
	{"resource",		no_argument,		NULL, 10 },
	{"show-personal",	no_argument,		NULL, 10 },
	{"no-personal",		no_argument,		NULL, 10 },
	{"show-tag-info",	no_argument,		NULL, 10 },
	{"no-tag-info",		no_argument,		NULL, 10 },
	{"filter-tag-include",	required_argument,	NULL, 11 },
	{"filter-tag-exclude",	required_argument,	NULL, 11 },
	{NULL,			0,			NULL, 0  }
    };
    int longindex;
#endif

    int ch, nopar = 0;
    size_t fstringlen = 64;
    const char *server = NULL, *port = NULL;
    char *qstring, *fstring;
    int ret;

#ifdef ENABLE_NLS
    setlocale(LC_ALL, "");
    bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
    textdomain(NLS_CAT_NAME);
#endif

    fstring = malloc(fstringlen + 1);
    *fstring = '\0';

    /* interface for American Fuzzy Lop */
    if (AFL_MODE) {
	FILE *fp = fdopen(0, "r");
	char *buf = NULL;
	size_t len = 0;

	/* read one line from stdin */
	if (getline(&buf, &len, fp) < 0)
	    err_sys("getline");
	fflush(fp);
	/* and use it as command line arguments */
	argv = merge_args(buf, argv, &argc);
    }

    /* prepend options from environment */
    argv = merge_args(getenv("WHOIS_OPTIONS"), argv, &argc);

    while ((ch = GETOPT_LONGISH(argc, argv,
		"abBcdFg:Gh:Hi:IKlLmMp:q:rRs:t:T:v:V:x",
		longopts, &longindex)) > 0) {
	/* RIPE flags */
	if (strchr(ripeflags, ch)) {
	    if (strlen(fstring) + 3 > fstringlen) {
		fstringlen += 3;
		fstring = realloc(fstring, fstringlen + 1);
	    }
	    sprintf(fstring + strlen(fstring), "-%c ", ch);
	    continue;
	}
	if (strchr(ripeflagsp, ch)) {
	    int flaglen = 3 + strlen(optarg) + 1;
	    if (strlen(fstring) + flaglen > fstringlen) {
		fstringlen += flaglen;
		fstring = realloc(fstring, fstringlen + 1);
	    }
	    sprintf(fstring + strlen(fstring), "-%c %s ", ch, optarg);
	    if (ch == 't' || ch == 'v' || ch == 'q')
		nopar = 1;
	    continue;
	}
	switch (ch) {
#ifdef HAVE_GETOPT_LONG
	/* long RIPE flags with no short equivalent */
	case 12:
		nopar = 1;
		/* fall through */
	case 10:
	    {
		int flaglen = 2 + strlen(longopts[longindex].name) + 1;
		if (strlen(fstring) + flaglen > fstringlen) {
		    fstringlen += flaglen;
		    fstring = realloc(fstring, fstringlen + 1);
		}
		sprintf(fstring + strlen(fstring), "--%s ",
			longopts[longindex].name);
	    }
	    break;
	case 11:
	    {
		int flaglen = 2 + strlen(longopts[longindex].name) + 1
		    + strlen(optarg) + 1;
		if (strlen(fstring) + flaglen > fstringlen) {
		    fstringlen += flaglen;
		    fstring = realloc(fstring, fstringlen + 1);
		}
		sprintf(fstring + strlen(fstring), "--%s %s ",
			longopts[longindex].name, optarg);
	    }
	    break;
#endif
	/* program flags */
	case 'h':
	    server = strdup(optarg);
	    break;
	case 'V':
	    client_tag = optarg;
	    break;
	case 'H':
	    hide_discl = HIDE_NOT_STARTED;	/* enable disclaimers hiding */
	    break;
	case 'I':
	    server = strdup("\x0E");
	    break;
	case 'p':
	    port = strdup(optarg);
	    break;
	case 4:
	    no_recursion = 1;
	    break;
	case 3:
	    usage(EXIT_SUCCESS);
	case 2:
	    verb = 1;
	    break;
	case 1:
	    fprintf(stdout, _("Version %s.\n\nReport bugs to %s.\n"),
		    VERSION, "<md+whois@linux.it>");
	    exit(EXIT_SUCCESS);
	default:
	    usage(EXIT_FAILURE);
	}
    }
    argc -= optind;
    argv += optind;

    if (argc == 0 && !nopar)	/* there is no parameter */
	usage(EXIT_FAILURE);

    /* On some systems realloc only works on non-NULL buffers */
    /* I wish I could remember which ones they are... */
    qstring = malloc(64);
    *qstring = '\0';

    /* parse other parameters, if any */
    if (!nopar) {
	int qstringlen = 0;

	while (1) {
	    qstringlen += strlen(*argv) + 1;
	    qstring = realloc(qstring, qstringlen + 1);
	    strcat(qstring, *argv++);
	    if (argc == 1)
		break;
	    strcat(qstring, " ");
	    argc--;
	}
    }

    signal(SIGTERM, sighandler);
    signal(SIGINT, sighandler);
    signal(SIGALRM, alarm_handler);

    if (getenv("WHOIS_HIDE"))
	hide_discl = HIDE_NOT_STARTED;

    /* -v or -t or long flags have been used */
    if (!server && (!*qstring || *fstring))
	server = strdup("whois.ripe.net");

    if (*qstring) {
	char *tmp = normalize_domain(qstring);
	free(qstring);
	qstring = tmp;
    }

#ifdef CONFIG_FILE
    if (!server)
	server = match_config_file(qstring);
#endif

    if (!server)
	server = guess_server(qstring);

    ret = handle_query(server, port, qstring, fstring);

    exit(ret);
}

/*
 * Server may be a server name from the command line, a server name got
 * from guess_server or an encoded command/message from guess_server.
 * This function has multiple memory leaks.
 */
int handle_query(const char *hserver, const char *hport,
	const char *query, const char *flags)
{
    char *server = NULL, *port = NULL;
    char *p, *query_string;

    if (hport) {
	server = strdup(hserver);
	port = strdup(hport);
    } else if (hserver[0] < ' ')
	server = strdup(hserver);
    else
	split_server_port(hserver, &server, &port);

    retry:
    switch (server[0]) {
	case 0:
	    if (!(server = getenv("WHOIS_SERVER")))
		server = strdup(DEFAULTSERVER);
	    break;
	case 1:
	    puts(_("This TLD has no whois server, but you can access the "
			"whois database at"));
	    puts(server + 1);
	    return 1;
	case 3:
	    puts(_("This TLD has no whois server."));
	    return 1;
	case 5:
	    puts(_("No whois server is known for this kind of object."));
	    return 1;
	case 6:
	    puts(_("Unknown AS number or IP network. Please upgrade this program."));
	    return 1;
	case 4:
	    if (verb)
		printf(_("Using server %s.\n"), server + 1);
	    sockfd = openconn(server + 1, NULL);
	    free(server);
	    server = query_crsnic(sockfd, query);
	    if (no_recursion && server)
		server[0] = '\0';
	    break;
	case 8:
	    if (verb)
		printf(_("Using server %s.\n"), server + 1);
	    sockfd = openconn(server + 1, NULL);
	    free(server);
	    server = query_afilias(sockfd, query);
	    if (no_recursion && server)
		server[0] = '\0';
	    break;
	case 0x0A:
	    p = convert_6to4(query);
	    printf(_("\nQuerying for the IPv4 endpoint %s of a 6to4 IPv6 address.\n\n"), p);
	    free(server);
	    server = guess_server(p);
	    query = p;
	    goto retry;
	case 0x0B:
	    p = convert_teredo(query);
	    printf(_("\nQuerying for the IPv4 endpoint %s of a Teredo IPv6 address.\n\n"), p);
	    free(server);
	    server = guess_server(p);
	    query = p;
	    goto retry;
	case 0x0C:
	    p = convert_inaddr(query);
	    free(server);
	    server = guess_server(p);
	    free(p);
	    goto retry;
	case 0x0D:
	    p = convert_in6arpa(query);
	    free(server);
	    server = guess_server(p);
	    free(p);
	    goto retry;
	case 0x0E:
	    if (verb)
		printf(_("Using server %s.\n"), "whois.iana.org");
	    sockfd = openconn("whois.iana.org", NULL);
	    free(server);
	    server = query_iana(sockfd, query);
	    break;
	default:
	    break;
    }

    if (!server)
	return 1;

    if (*server == '\0')
	return 0;

    query_string = queryformat(server, flags, query);
    if (verb) {
	printf(_("Using server %s.\n"), server);
	printf(_("Query string: \"%s\"\n\n"), query_string);
    }

    sockfd = openconn(server, port);
    free(server);
    server = do_query(sockfd, query_string);
    free(query_string);

    /* recursion is fun */
    if (!no_recursion && server && !strchr(query, ' ')) {
	printf(_("\n\nFound a referral to %s.\n\n"), server);
	handle_query(server, NULL, query, flags);
    }

    return 0;
}

#ifdef CONFIG_FILE
const char *match_config_file(const char *s)
{
    FILE *fp;
    char buf[512];
    static const char delim[] = " \t";

    if ((fp = fopen(CONFIG_FILE, "r")) == NULL) {
	if (errno != ENOENT)
	    err_sys("Cannot open " CONFIG_FILE);
	return NULL;
    }

    while (fgets(buf, sizeof(buf), fp) != NULL) {
	char *p;
	const char *pattern, *server;
#ifdef HAVE_REGEXEC
	int i;
	regex_t re;
#endif

	if ((p = strpbrk(buf, "\r\n")))
	    *p = '\0';

	p = buf;
	while (*p == ' ' || *p == '\t')	/* eat leading blanks */
	    p++;
	if (!*p)
	    continue;		/* skip empty lines */
	if (*p == '#')
	    continue;		/* skip comments */

	pattern = strtok(p, delim);
	server = strtok(NULL, delim);
	if (!pattern || !server)
	    err_quit(_("Cannot parse this line: %s"), p);
	p = strtok(NULL, delim);
	if (p)
	    err_quit(_("Cannot parse this line: %s"), p);

#ifdef HAVE_REGEXEC
	i = regcomp(&re, pattern, REG_EXTENDED | REG_ICASE | REG_NOSUB);
	if (i != 0) {
	    char m[1024];
	    regerror(i, &re, m, sizeof(m));
	    err_quit("Invalid regular expression '%s': %s", pattern, m);
	}

	i = regexec(&re, s, 0, NULL, 0);
	if (i == 0) {
	    regfree(&re);
	    fclose(fp);
	    return strdup(server);
	}
	if (i != REG_NOMATCH) {
	    char m[1024];
	    regerror(i, &re, m, sizeof(m));
	    err_quit("regexec: %s",  m);
	}
	regfree(&re);
#else
	if (endstrcaseeq(s, pattern)) {
	    fclose(fp);
	    return strdup(server);
	}
#endif
    }
    fclose(fp);
    return NULL;
}
#endif

/*
 * Check if the argument is an autonomous system number in the form "ASnnnn"
 * or "AS nnnn".
 */
int is_asn(const char *s, int allow_space, const char *suffix_separators)
{
    const char *p;
    int max_numbers = 6;
    int seen_number = 0;

    if (!strncaseeq(s, "as", 2))
	return 0;	 /* does not start with "as" (case insensitive) */

    /* skip a single optional space */
    p = s + 2;
    if (allow_space && *p == ' ')
	p++;

    /* all numbers, but not too many */
    while (*p) {
	if (*p < '0' || *p > '9') {	/* not a number */
	    if (!seen_number)
		return 0;		/* just "as" with no numbers */
	    if (suffix_separators && strchr(suffix_separators, *p))
		return 1;		/* has a trailing separator */
	    return 0;			/* has trailing garbage */
	}

	seen_number = 1;
	if (max_numbers-- == 0)
	    return 0;			/* too many numbers */
	p++;
    }

    if (seen_number)
	return 1;			/* a real ASN */
    else
	return 0;			/* trailing garbage */
}

/* Parses an user-supplied string and tries to guess the right whois server.
 * Returns a dynamically allocated buffer.
 */
char *guess_server(const char *s)
{
    unsigned long ip;
    unsigned int i;
    const char *colon, *tld;

    /* IPv6 address */
    if ((colon = strchr(s, ':'))) {
	unsigned long v6prefix, v6net;

	/* RPSL hierarchical objects */
	if (is_asn(s, 0, ":"))
	    return strdup(whereas(atol(s + 2)));

	v6prefix = strtol(s, NULL, 16);

	if (v6prefix == 0)
	    return strdup("\x05");		/* unknown */

	v6net = (v6prefix << 16) + strtol(colon + 1, NULL, 16);/* second u16 */

	for (i = 0; ip6_assign[i].serv; i++) {
	    if ((v6net & (~0UL << (32 - ip6_assign[i].masklen)))
		    == ip6_assign[i].net)
		return strdup(ip6_assign[i].serv);
	}

	return strdup("\x06");			/* unknown allocation */
    }

    /* email address */
    if (strchr(s, '@'))
	return strdup("\x05");

    if (!strpbrk(s, ".")) {
	/* if it is a TLD or a new gTLD then ask IANA */
	for (i = 0; tld_serv[i]; i += 2)
	    if (strcaseeq(s, tld_serv[i]))
		return strdup("whois.iana.org");

	for (i = 0; new_gtlds[i]; i++)
	    if (strcaseeq(s, new_gtlds[i]))
		return strdup("whois.iana.org");
    }

    /* no dot and no hyphen means it's a NSI NIC handle or ASN (?) */
    if (!strpbrk(s, ".-")) {
	if (is_asn(s, 1, NULL))
	    return strdup(whereas(atol(s + 2))); /* it's an AS */
	if (*s == '!')	/* NSI NIC handle */
	    return strdup("whois.networksolutions.com");
	else
	    return strdup("\x05"); /* probably a unknown kind of nic handle */
    }

    /* smells like an IP? */
    if ((ip = myinet_aton(s))) {
	for (i = 0; ip_assign[i].serv; i++)
	    if ((ip & ip_assign[i].mask) == ip_assign[i].net)
		return strdup(ip_assign[i].serv);
	return strdup("\x05");		/* not in the unicast IPv4 space */
    }

    /* check the TLDs list */
    for (i = 0; tld_serv[i]; i += 2)
	if (in_domain(s, tld_serv[i]))
	    return strdup(tld_serv[i + 1]);

    /* use the default server name for "new" gTLDs */
    if ((tld = is_new_gtld(s))) {
	char *server = malloc(strlen("whois.nic.") + strlen(tld) + 1);
	strcpy(server, "whois.nic.");
	strcat(server, tld);
	return server;
    }

    /* no dot but hyphen */
    if (!strchr(s, '.')) {
	/* search for strings at the start of the word */
	for (i = 0; nic_handles[i]; i += 2)
	    if (strncaseeq(s, nic_handles[i], strlen(nic_handles[i])))
		return strdup(nic_handles[i + 1]);

	/* search for strings at the end of the word */
	for (i = 0; nic_handles_post[i]; i += 2)
	    if (endstrcaseeq(s, nic_handles_post[i]))
		return strdup(nic_handles_post[i + 1]);

	/* it's probably a network name */
	return strdup("");
    }

    /* has dot and maybe a hyphen and it's not in tld_serv[], WTF is it? */
    /* either a TLD or a NIC handle we don't know about yet */
    return strdup("\x05");
}

const char *whereas(const unsigned long asn)
{
    int i;

    for (i = 0; as_assign[i].serv; i++)
	if (asn >= as_assign[i].first && asn <= as_assign[i].last)
	    return as_assign[i].serv;
    return "\x06";
}

/*
 * Construct the query string.
 * Determines the server character set as a side effect.
 * Returns a malloc'ed string which needs to be freed by the caller.
 */
char *queryformat(const char *server, const char *flags, const char *query)
{
    char *buf;
    int i, isripe = 0;

    /* 64 bytes reserved for server-specific flags added later */
    buf = malloc(strlen(flags) + strlen(query) + strlen(client_tag) + 64);
    *buf = '\0';

    for (i = 0; ripe_servers[i]; i++)
	if (streq(server, ripe_servers[i])) {
	    sprintf(buf + strlen(buf), "-V %s ", client_tag);
	    isripe = 1;
	    break;
	}

    if (*flags) {
	if (!isripe)
	    puts(_("Warning: RIPE flags used with a traditional server."));
	strcat(buf, flags);
    }

#ifdef HAVE_ICONV
    simple_recode_iconv_close();
    for (i = 0; servers_charset[i].name; i++)
	if (streq(server, servers_charset[i].name)) {
	    simple_recode_input_charset = servers_charset[i].charset;
	    if (servers_charset[i].options) {
		strcat(buf, servers_charset[i].options);
		strcat(buf, " ");
	    }
	    break;
	}

    /* Use UTF-8 by default for "new" gTLDs */
    if (!simple_recode_input_charset &&		/* was not in the database */
	    !strchr(query, ' ') &&		/* and has no parameters */
	    is_new_gtld(query))			/* and is a "new" gTLD: */
	simple_recode_input_charset = "utf-8";	/* then try UTF-8 */
#endif

#if defined HAVE_LIBIDN || defined HAVE_LIBIDN2
# define DENIC_PARAM_ACE ",ace"
#else
# define DENIC_PARAM_ACE ""
#endif
#ifdef HAVE_ICONV
# define DENIC_PARAM_CHARSET ""
#else
# define DENIC_PARAM_CHARSET " -C US-ASCII"
#endif

    /* add useful default flags if there are no flags or multiple arguments */
    if (isripe) { }
    else if (strchr(query, ' ') || *flags) { }
    else if (streq(server, "whois.denic.de") && in_domain(query, "de"))
	strcat(buf, "-T dn" DENIC_PARAM_ACE DENIC_PARAM_CHARSET " ");
    else if ((streq(server, "whois.punktum.dk") ||
		streq(server, "whois.dk-hostmaster.dk"))
	    && in_domain(query, "dk"))
	strcat(buf, "--show-handles ");

    /* mangle and add the query string */
    if (!isripe && streq(server, "whois.nic.ad.jp") &&
	    is_asn(query, 1, NULL)) {
	strcat(buf, "AS ");
	strcat(buf, query + 2);
    }
    else if (!isripe && streq(server, "whois.arin.net") &&
	    !strrchr(query, ' ')) {
	if (is_asn(query, 0, NULL)) {
	    strcat(buf, "a ");
	    strcat(buf, query + 2);
	} else if (myinet_aton(query) || strchr(query, ':')) {
	    if (strchr(query, '/'))
		strcat(buf, "r + = ");
	    else
		strcat(buf, "n + ");
	    strcat(buf, query);
	} else
	    strcat(buf, query);
    }
    else
	strcat(buf, query);

    /* ask for english text */
    if (!isripe && (streq(server, "whois.nic.ad.jp") ||
	    streq(server, "whois.jprs.jp")) && japanese_locale()) {
	/* but not if the user already added the /e flag */
	char *flag = buf + strlen(buf) - 2;
	if (!streq(flag, "/e"))
	    strcat(buf, "/e");
    }

    return buf;
}

/* the first parameter contains the state of this simple state machine:
 * HIDE_DISABLED: hidden text finished
 * HIDE_NOT_STARTED: hidden text not seen yet
 * >= 0: currently hiding message hide_strings[*hiding]
 */
int hide_line(int *hiding, const char *const line)
{
    int i;

    if (*hiding == HIDE_TO_THE_END) {
	return 1;
    } else if (*hiding == HIDE_DISABLED) {
	return 0;
    } else if (*hiding == HIDE_NOT_STARTED) {	/* looking for smtng to hide */
	for (i = 0; hide_strings[i] != NULL; i += 2) {
	    if (strneq(line, hide_strings[i], strlen(hide_strings[i]))) {
		if (hide_strings[i + 1] == NULL)
		    *hiding = HIDE_TO_THE_END;	/* all the remaining output */
		else
		    *hiding = i;		/* start hiding */
		return 1;			/* and hide this line */
	    }
	}
	return 0;				/* don't hide this line */
    } else if (*hiding > HIDE_NOT_STARTED) {	/* hiding something */
	if (*hide_strings[*hiding + 1] == '\0')	{ /*look for a blank line?*/
	    if (*line == '\n' || *line == '\r' || *line == '\0') {
		*hiding = HIDE_NOT_STARTED;	/* stop hiding */
		return 0;		/* but do not hide the blank line */
	    }
	} else {				/*look for a matching string*/
	    if (strneq(line, hide_strings[*hiding + 1],
			strlen(hide_strings[*hiding + 1]))) {
		*hiding = HIDE_NOT_STARTED;	/* stop hiding */
		return 1;			/* but hide the last line */
	    }
	}
	return 1;				/* we are hiding, so do it */
    } else
	return 0;
}

/* returns a string which should be freed by the caller, or NULL */
char *do_query(const int sock, const char *query)
{
    char *temp, *p, buf[2000];
    FILE *fi;
    int hide = hide_discl;
    char *referral_server = NULL;

    temp = malloc(strlen(query) + 2 + 1);
    strcpy(temp, query);
    strcat(temp, "\r\n");

    fi = fdopen(sock, "r");
    if (write(sock, temp, strlen(temp)) < 0)
	err_sys("write");
    free(temp);

    while (fgets(buf, sizeof(buf), fi)) {
	/* 6bone-style referral:
	 * % referto: whois -h whois.arin.net -p 43 as 1
	 */
	if (!referral_server && strneq(buf, "% referto:", 10)) {
	    char nh[256], np[16], nq[1024];

	    if (sscanf(buf, REFERTO_FORMAT, nh, np, nq) == 3) {
		/* XXX we are ignoring the new query string */
		referral_server = malloc(strlen(nh) + 1 + strlen(np) + 1);
		sprintf(referral_server, "%s:%s", nh, np);
	    }
	}

	/* ARIN referrals:
	 * ReferralServer: rwhois://rwhois.fuse.net:4321/
	 * ReferralServer: whois://whois.ripe.net
	 */
	if (!referral_server && strneq(buf, "ReferralServer:", 15)) {
	    if ((p = strstr(buf, "rwhois://")))
		referral_server = strdup(p + 9);
	    else if ((p = strstr(buf, "whois://")))
		referral_server = strdup(p + 8);
	    if (referral_server && (p = strpbrk(referral_server, "/\r\n")))
		*p = '\0';
	}

	if (hide_line(&hide, buf))
	    continue;

	if ((p = strpbrk(buf, "\r\n")))
	    *p = '\0';
	recode_fputs(buf, stdout);
	fputc('\n', stdout);
    }

    if (ferror(fi))
	err_sys("fgets");
    fclose(fi);

    if (hide > HIDE_NOT_STARTED && hide != HIDE_TO_THE_END)
	err_quit(_("Catastrophic error: disclaimer text has been changed.\n"
		   "Please upgrade this program.\n"));

    return referral_server;
}

char *query_crsnic(const int sock, const char *query)
{
    char *temp, *p, buf[2000];
    FILE *fi;
    int hide = hide_discl;
    char *referral_server = NULL;
    int state = 0;
    int dotscount = 0;

    temp = malloc(strlen("domain ") + strlen(query) + 2 + 1);
    *temp = '\0';

    /* if this has more than one dot then it is a name server */
    for (p = (char *) query; *p != '\0'; p++)
	if (*p == '.')
	    dotscount++;

    if (dotscount == 1 && !strpbrk(query, "=~ "))
	strcpy(temp, "domain ");
    strcat(temp, query);
    strcat(temp, "\r\n");

    fi = fdopen(sock, "r");
    if (write(sock, temp, strlen(temp)) < 0)
	err_sys("write");
    free(temp);

    while (fgets(buf, sizeof(buf), fi)) {
	/* If there are multiple matches only the server of the first record
	   is queried */
	if (state == 0 && strneq(buf, "   Domain Name:", 15))
	    state = 1;
	if (state == 0 && strneq(buf, "   Server Name:", 15)) {
	    referral_server = strdup("");
	    state = 2;
	}
	if (state == 1 && strneq(buf, "   Registrar WHOIS Server:", 26)) {
	    for (p = buf; *p != ':'; p++);	/* skip until the colon */
	    for (p++; *p == ' '; p++);		/* skip the spaces */
	    referral_server = strdup(p);
	    if ((p = strpbrk(referral_server, "\r\n ")))
		*p = '\0';
	    state = 2;
	}

	/* the output must not be hidden or no data will be shown for
	   host records and not-existing domains */
	if (hide_line(&hide, buf))
	    continue;

	if ((p = strpbrk(buf, "\r\n")))
	    *p = '\0';
	recode_fputs(buf, stdout);
	fputc('\n', stdout);
    }

    if (ferror(fi))
	err_sys("fgets");
    fclose(fi);

    return referral_server;
}

char *query_afilias(const int sock, const char *query)
{
    char *temp, *p, buf[2000];
    FILE *fi;
    int hide = hide_discl;
    char *referral_server = NULL;
    int state = 0;

    temp = malloc(strlen(query) + 2 + 1);
    strcpy(temp, query);
    strcat(temp, "\r\n");

    fi = fdopen(sock, "r");
    if (write(sock, temp, strlen(temp)) < 0)
	err_sys("write");
    free(temp);

    while (fgets(buf, sizeof(buf), fi)) {
	/* If multiple attributes are returned then use the first result.
	   This is not supposed to happen. */
	if (state == 0 && strneq(buf, "Domain Name:", 12))
	    state = 1;
	if (state == 1 && strneq(buf, "Registrar WHOIS Server:", 23)) {
	    for (p = buf; *p != ':'; p++);	/* skip until colon */
	    for (p++; *p == ' '; p++);		/* skip colon and spaces */
	    referral_server = strdup(p);
	    if ((p = strpbrk(referral_server, "\r\n ")))
		*p = '\0';
	    state = 2;
	}

	/* the output must not be hidden or no data will be shown for
	   host records and not-existing domains */
	if (hide_line(&hide, buf))
	    continue;

	if ((p = strpbrk(buf, "\r\n")))
	    *p = '\0';
	recode_fputs(buf, stdout);
	fputc('\n', stdout);
    }

    if (ferror(fi))
	err_sys("fgets");
    fclose(fi);

    if (hide > HIDE_NOT_STARTED && hide != HIDE_TO_THE_END)
	err_quit(_("Catastrophic error: disclaimer text has been changed.\n"
		   "Please upgrade this program.\n"));

    return referral_server;
}

char *query_iana(const int sock, const char *query)
{
    char *temp, *p, buf[2000];
    FILE *fi;
    char *referral_server = NULL;
    int state = 0;

    temp = malloc(strlen(query) + 2 + 1);
    strcpy(temp, query);
    strcat(temp, "\r\n");

    fi = fdopen(sock, "r");
    if (write(sock, temp, strlen(temp)) < 0)
	err_sys("write");
    free(temp);

    while (fgets(buf, sizeof(buf), fi)) {
	/* If multiple attributes are returned then use the first result.
	   This is not supposed to happen. */
	if (state == 0 && strneq(buf, "refer:", 6)) {
	    for (p = buf; *p != ':'; p++);	/* skip until colon */
	    for (p++; *p == ' '; p++);		/* skip colon and spaces */
	    referral_server = strdup(p);
	    if ((p = strpbrk(referral_server, "\r\n ")))
		*p = '\0';
	    state = 2;
	}

	if ((p = strpbrk(buf, "\r\n")))
	    *p = '\0';
	recode_fputs(buf, stdout);
	fputc('\n', stdout);
    }

    if (ferror(fi))
	err_sys("fgets");
    fclose(fi);

    return referral_server;
}

int openconn(const char *server, const char *port)
{
    int fd = -1;
    int timeout = 10;
#ifdef HAVE_GETADDRINFO
    int err;
    struct addrinfo hints, *res, *ai;
#else
    struct hostent *hostinfo;
    struct servent *servinfo;
    struct sockaddr_in saddr;
#endif

    /*
     * When using American Fuzzy Lop get the data from it using stdin
     * instead of connecting to the actual whois server.
     */
    if (AFL_MODE)
	return dup(0);

    alarm(60);

#ifdef HAVE_GETADDRINFO
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_ADDRCONFIG;
    hints.ai_flags |= AI_IDN;

    if ((err = getaddrinfo(server, port ? port : "nicname", &hints, &res))
	    != 0) {
	if (err == EAI_SYSTEM)
	    err_sys("getaddrinfo(%s)", server);
	else
	    err_quit("getaddrinfo(%s): %s", server, gai_strerror(err));
    }

    for (ai = res; ai; ai = ai->ai_next) {
	/* no timeout for the last address. is this a good idea? */
	if (!ai->ai_next)
	    timeout = 0;
	if ((fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) < 0)
	    continue;		/* ignore */
	if (connect_with_timeout(fd, (struct sockaddr *)ai->ai_addr,
		    ai->ai_addrlen, timeout) == 0)
	    break;		/* success */
	close(fd);
    }
    freeaddrinfo(res);

    if (!ai)
	err_sys("connect");
#else
    if ((hostinfo = gethostbyname(server)) == NULL)
	err_quit(_("Host %s not found."), server);
    if ((fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) < 0)
	err_sys("socket");
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_addr = *(struct in_addr *) hostinfo->h_addr;
    saddr.sin_family = AF_INET;
    if (!port) {
	saddr.sin_port = htons(43);
    } else if ((saddr.sin_port = htons(atoi(port))) == 0) {
	if ((servinfo = getservbyname(port, "tcp")) == NULL)
	    err_quit(_("%s/tcp: unknown service"), port);
	saddr.sin_port = servinfo->s_port;
    }
    if (connect_with_timeout(fd, (struct sockaddr *)&saddr, sizeof(saddr),
		timeout) < 0)
	err_sys("connect");
#endif

    return fd;
}

int connect_with_timeout(int fd, const struct sockaddr *addr,
	socklen_t addrlen, int timeout)
{
    int savedflags, rc, connect_errno, opt;
    unsigned int len;
    fd_set fd_w;
    struct timeval tv;

    if (timeout <= 0)
	return connect(fd, addr, addrlen);

    if ((savedflags = fcntl(fd, F_GETFL, 0)) < 0)
	return -1;

    /* set the socket non-blocking, so connect(2) will return immediately */
    if (fcntl(fd, F_SETFL, savedflags | O_NONBLOCK) < 0)
	return -1;

    rc = connect(fd, addr, addrlen);

    /* set the socket to block again */
    connect_errno = errno;
    if (fcntl(fd, F_SETFL, savedflags) < 0)
	return -1;
    errno = connect_errno;

    if (rc == 0 || errno != EINPROGRESS)
	return rc;

    FD_ZERO(&fd_w);
    FD_SET(fd, &fd_w);
    tv.tv_sec = timeout;
    tv.tv_usec = 0;

    /* loop until an error or the timeout has expired */
    do {
	rc = select(fd + 1, NULL, &fd_w, NULL, &tv);
    } while (rc == -1 && errno == EINTR);

    if (rc == 0) {		/* timed out */
	errno = ETIMEDOUT;
	return -1;
    }

    if (rc < 0 || rc > 1)	/* select failed */
	return rc;

    /* rc == 1: success. check for errors */
    len = sizeof(opt);
    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &opt, &len) < 0)
	return -1;

    /* and report them */
    if (opt != 0) {
	errno = opt;
	return -1;
    }

    return 0;
}

void NORETURN alarm_handler(UNUSED int signum)
{
    close(sockfd);
    err_quit(_("Timeout."));
}

void NORETURN sighandler(int signum)
{
    close(sockfd);
    err_quit(_("Interrupted by signal %d..."), signum);
}

int japanese_locale(void)
{
    char *lang;

    lang = getenv("LC_MESSAGES");
    if (lang) {
	if (strneq(lang, "ja", 2))
	    return 0;
	return 1;
    }

    lang = getenv("LANG");
    if (lang && strneq(lang, "ja", 2))
	return 0;
    return 1;
}

/* check if dom ends with tld */
int endstrcaseeq(const char *dom, const char *tld)
{
    size_t dom_len, tld_len;
    const char *p = NULL;

    if ((dom_len = strlen(dom)) == 0)
	return 0;

    if ((tld_len = strlen(tld)) == 0)
	return 0;

    /* dom cannot be shorter than what we are looking for */
    if (tld_len > dom_len)
	return 0;

    p = dom + dom_len - tld_len;

    return strcaseeq(p, tld);
}

/* check if dom is a subdomain of tld */
int in_domain(const char *dom, const char *tld)
{
    size_t dom_len, tld_len;
    const char *p = NULL;

    if ((dom_len = strlen(dom)) == 0)
	return 0;

    if ((tld_len = strlen(tld)) == 0)
	return 0;

    /* dom cannot be shorter than what we are looking for */
    /* -1 to ignore dom containing just a dot and tld */
    if (tld_len >= dom_len - 1)
	return 0;

    p = dom + dom_len - tld_len;

    /* fail if the character before tld is not a dot */
    if (*(p - 1) != '.')
	return 0;

    return strcaseeq(p, tld);
}

const char *is_new_gtld(const char *s)
{
    int i;

    for (i = 0; new_gtlds[i]; i++)
	if (in_domain(s, new_gtlds[i]))
	    return new_gtlds[i];

    return NULL;
}

/*
 * Attempt to normalize a query by removing trailing dots and whitespace,
 * then convert the domain to punycode.
 * The function assumes that the domain is the last token of the query.
 * Returns a malloc'ed string which needs to be freed by the caller.
 */
char *normalize_domain(const char *dom)
{
    char *p, *ret;
#if defined HAVE_LIBIDN || defined HAVE_LIBIDN2
    char *domain_start = NULL;
#endif

    ret = strdup(dom);
    /* start from the last character */
    p = ret + strlen(ret) - 1;
    /* and then eat trailing dots and blanks */
    while (p > ret) {
	if (!(*p == '.' || *p == ' ' || *p == '\t'))
	    break;
	*p = '\0';
	p--;
    }

#if defined HAVE_LIBIDN || defined HAVE_LIBIDN2
    /* find the start of the last word if there are spaces in the query */
    for (p = ret; *p; p++)
	if (*p == ' ')
	    domain_start = p + 1;

    if (domain_start) {
	char *q, *r;
	int prefix_len;

#ifdef HAVE_LIBIDN2
	if (idn2_lookup_ul(domain_start, &q, IDN2_NONTRANSITIONAL) != IDN2_OK)
	    return ret;
#else
	if (idna_to_ascii_lz(domain_start, &q, 0) != IDNA_SUCCESS)
	    return ret;
#endif

	/* reassemble the original query in a new buffer */
	prefix_len = domain_start - ret;
	r = malloc(prefix_len + strlen(q) + 1);
	strncpy(r, ret, prefix_len);
	r[prefix_len] = '\0';
	strcat(r, q);

	free(q);
	free(ret);
	return r;
    } else {
	char *q;

#ifdef HAVE_LIBIDN2
	if (idn2_lookup_ul(ret, &q, IDN2_NONTRANSITIONAL) != IDN2_OK)
	    return ret;
#else
	if (idna_to_ascii_lz(ret, &q, 0) != IDNA_SUCCESS)
	    return ret;
#endif

	free(ret);
	return q;
    }
#else
    return ret;
#endif
}

/* server and port have to be freed by the caller */
void split_server_port(const char *const input,
	char **server, char **port)
{
    char *p;

    if (*input == '[' && (p = strchr(input, ']'))) {	/* IPv6 */
	char *s;
	int len = p - input - 1;

	*server = s = malloc(len + 1);
	memcpy(s, input + 1, len);
	*(s + len) = '\0';

	p = strchr(p, ':');
	if (p && *(p + 1) != '\0')
	    *port = strdup(p + 1);			/* IPv6 + port */
    } else if ((p = strchr(input, ':')) &&		/* IPv6, no port */
	    strchr(p + 1, ':')) {			/*   and no brackets */
	*server = strdup(input);
    } else if ((p = strchr(input, ':'))) {		/* IPv4 + port */
	char *s;
	int len = p - input;

	*server = s = malloc(len + 1);
	memcpy(s, input, len);
	*(s + len) = '\0';

	p++;
	if (*p != '\0')
	    *port = strdup(p);
    } else {						/* IPv4, no port */
	*server = strdup(input);
    }

    /* change the server name to lower case */
    for (p = (char *) *server; *p; p++)
	*p = tolower(*p);
}

char *convert_6to4(const char *s)
{
    char *new;
    int items;
    unsigned int a, b;
    char c;

    items = sscanf(s, "2002:%x:%x%c", &a, &b, &c);

    if (items <= 0 || items == 2 || (items == 3 && c != ':'))
	return strdup("0.0.0.0");

    if (items == 1) {
	items = sscanf(s, "2002:%x:%c", &a, &c);
	if (items != 2 || c != ':')
	    return strdup("0.0.0.0");
	b = 0;
    }

    new = malloc(sizeof("255.255.255.255"));
    sprintf(new, "%u.%u.%u.%u", a >> 8, a & 0xff, b >> 8, b & 0xff);

    return new;
}

char *convert_teredo(const char *s)
{
    char *new;
    unsigned int a, b;

    if (sscanf(s, "2001:%*[^:]:%*[^:]:%*[^:]:%*[^:]:%*[^:]:%x:%x", &a, &b) != 2)
	return strdup("0.0.0.0");

    a ^= 0xffff;
    b ^= 0xffff;
    new = malloc(sizeof("255.255.255.255"));
    sprintf(new, "%u.%u.%u.%u", a >> 8, a & 0xff, b >> 8, b & 0xff);

    return new;
}

char *convert_inaddr(const char *s)
{
    char *new;
    char *endptr;
    long int a, b = 0, c = 0;

    errno = 0;

    a = strtol(s, &endptr, 10);
    if (errno || a < 0 || a > 255 || *endptr != '.')
	return strdup("0.0.0.0");

    if (in_domain(endptr + 1, "in-addr.arpa")) {
	b = strtol(endptr + 1, &endptr, 10);			/* 1.2. */
	if (errno || b < 0 || b > 255 || *endptr != '.')
	    return strdup("0.0.0.0");

	if (in_domain(endptr + 1, "in-addr.arpa")) {
	    c = strtol(endptr + 1, &endptr, 10);		/* 1.2.3. */
	    if (errno || c < 0 || c > 255 || *endptr != '.')
		return strdup("0.0.0.0");

	    if (in_domain(endptr + 1, "in-addr.arpa"))
		return strdup("0.0.0.0");
	} else {
	    c = b; b = a; a = 0;
	}
    } else {
	c = a; a = 0;
    }

    new = malloc(sizeof("255.255.255.255"));
    sprintf(new, "%ld.%ld.%ld.0", c, b, a);
    return new;
}

char *convert_in6arpa(const char *s)
{
    char *ip, *p;
    int character = 0;
    int digits = 1;

    ip = malloc(40);

    p = strstr(s, ".ip6.arpa");
    if (!p || p == s) {
	ip[character] = '\0';
	return ip;
    }

    /* start from the first character before ".ip6.arpa" */
    p--;

    while (1) {
	/* check that this is a valid digit for an IPv6 address */
	if (!((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') ||
	      (*p >= 'A' && *p <= 'F'))) {
	    ip[character] = '\0';
	    return ip;
	}

	/* copy the digit to the IP address */
	ip[character++] = *p;

	/* stop if we have reached the beginning of the string */
	if (p == s)
	    break;

	/* stop if we have parsed a complete address */
	if (character == 39)
	    break;

	/* add the colon separator every four digits */
	if ((digits++ % 4) == 0)
	    ip[character++] = ':';

	/* go to the precedent character and abort if it is not a dot */
	p--;
	if (*p != '.') {
	    ip[character] = '\0';
	    return ip;
	}

	/* abort if the string starts with the dot */
	if (p == s) {
	    ip[character] = '\0';
	    return ip;
	}

	/* go to the precedent character and continue */
	p--;
    }

    /* terminate the string */
    ip[character] = '\0';
    return ip;
}

unsigned long myinet_aton(const char *s)
{
    unsigned long a, b, c, d;
    int elements;
    char junk;

    if (!s)
	return 0;
    elements = sscanf(s, "%lu.%lu.%lu.%lu%c", &a, &b, &c, &d, &junk);
    if (!(elements == 4 || (elements == 5 && junk == '/')))
	return 0;
    if (a > 255 || b > 255 || c > 255 || d > 255)
	return 0;
    return (a << 24) + (b << 16) + (c << 8) + d;
}

int isasciidigit(const char c)
{
    return (c >= '0' && c <= '9') ? 1 : 0;
}

/* https://www.ripe.net/ripe/docs/databaseref-manual.html */

void NORETURN usage(int error)
{
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"Usage: whois [OPTION]... OBJECT...\n\n"
"-h HOST, --host HOST   connect to server HOST\n"
"-p PORT, --port PORT   connect to PORT\n"
"-I                     query whois.iana.org and follow its referral\n"
"-H                     hide legal disclaimers\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"      --verbose        explain what is being done\n"
"      --no-recursion   disable recursion from registry to registrar servers\n"
"      --help           display this help and exit\n"
"      --version        output version information and exit\n"
"\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"These flags are supported by whois.ripe.net and some RIPE-like servers:\n"
"-l                     find the one level less specific match\n"
"-L                     find all levels less specific matches\n"
"-m                     find all one level more specific matches\n"
"-M                     find all levels of more specific matches\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"-c                     find the smallest match containing a mnt-irt attribute\n"
"-x                     exact match\n"
"-b                     return brief IP address ranges with abuse contact\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"-B                     turn off object filtering (show email addresses)\n"
"-G                     turn off grouping of associated objects\n"
"-d                     return DNS reverse delegation objects too\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"-i ATTR[,ATTR]...      do an inverse look-up for specified ATTRibutes\n"
"-T TYPE[,TYPE]...      only look for objects of TYPE\n"
"-K                     only primary keys are returned\n"
"-r                     turn off recursive look-ups for contact information\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"-R                     force to show local copy of the domain object even\n"
"                       if it contains referral\n"
"-a                     also search all the mirrored databases\n"
"-s SOURCE[,SOURCE]...  search the database mirrored from SOURCE\n"
"-g SOURCE:FIRST-LAST   find updates from SOURCE from serial FIRST to LAST\n"
    ));
    fprintf((EXIT_SUCCESS == error) ? stdout : stderr, _(
"-t TYPE                request template for object of TYPE\n"
"-v TYPE                request verbose template for object of TYPE\n"
"-q [version|sources|types]  query specified server info\n"
));
    exit(error);
}