Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-31 11:51:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Create a branch for network fixes.

Browse source 
svn path=/branches/aicom-network-fixes/; revision=34994
This commit is contained in:
Art Yerkes 2008-08-01 11:32:26 +00:00
parent 0e213bbc00
commit c501d8112c
18148 changed files with 0 additions and 860488 deletions
Download patch file Download diff file Expand all files Collapse all files

82
lib/3rdparty/adns/client/Makefile.in vendored Normal file
View file

@ -0,0 +1,82 @@
# client/Makefile - client program(s) Makefile
#
# This file is
# Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
#
# It is part of adns, which is
# Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
# Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
#
# 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
srcdir= @srcdir@
VPATH= @srcdir@
PROGS_SYSDEP= @PROGS_HAVE_TSEARCH@
ENABLE_DYNAMIC= @ENABLE_DYNAMIC@
PROGRAMS= adnslogres adnshost $(PROGS_SYSDEP)
PROGRAMS_LOCAL= fanftest adnstest
PROGRAMS_ALL= $(PROGRAMS) $(PROGRAMS_LOCAL)
STATIC_LIB= $(ADNSDIR)/libadns.a
ifeq ($(ENABLE_DYNAMIC),elf)
DYNAMIC_DEP= $(srcdir)/../dynamic/$(SHLIBFILE)
DYNAMIC_LINK= -L$(srcdir)/../dynamic -ladns
DYNAMIC_SUFFIX= _s
else
DYNAMIC_DEP= $(STATIC_LIB)
DYNAMIC_LINK= $(STATIC_LIB)
DYNAMIC_SUFFIX=
endif
TARG_INSTALL= $(PROGRAMS)
TARG_LOCAL= $(addsuffix $(DYNAMIC_SUFFIX), $(PROGRAMS_ALL))
TARGETS= $(TARG_LOCAL) $(TARG_INSTALL)
include $(srcdir)/../settings.make
DIRCFLAGS= -I$(srcdir)/../src
TARG_OBJS= $(addsuffix .o, $(PROGRAMS_ALL))
ADH_OBJS= adh-main.o adh-opts.o adh-query.o
ALL_OBJS= $(ADH_OBJS) $(TARG_OBJS)
ADNSDIR= $(srcdir)/../src/
all: $(TARGETS)
install: $(TARG_INSTALL)
set -xe; for f in $(TARG_INSTALL); \
do $(INSTALL_PROGRAM) $$f $(bin_dir)/$$f; done
uninstall:
for f in $(TARGETS); do rm -f $(bin_dir)/$$f; done
adnshost: $(ADH_OBJS) $(DYNAMIC_DEP)
$(CC) $(LDFLAGS) $(ADH_OBJS) $(DYNAMIC_LINK) -o $@ $(LDLIBS)
adnshost_s: $(ADH_OBJS) $(STATIC_LIB)
$(CC) $(LDFLAGS) $(ADH_OBJS) $(STATIC_LIB) -o $@ $(LDLIBS)
$(ADH_OBJS): adnshost.h
$(ALL_OBJS): $(ADNSDIR)/adns.h $(ADNSDIR)/config.h
adnsresfilter.o: $(ADNSDIR)/tvarith.h
%: %.o $(DYNAMIC_DEP)
$(CC) $(LDFLAGS) $< $(DYNAMIC_LINK) -o $@ $(LDLIBS)
%_s: %.o $(STATIC_LIB)
$(CC) $(LDFLAGS) $< $(STATIC_LIB) -o $@ $(LDLIBS)

272
lib/3rdparty/adns/client/adh-main.c vendored Normal file
View file

@ -0,0 +1,272 @@
/*
* adh-main.c
* - useful general-purpose resolver client program
* main program and useful subroutines
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
# include <io.h>
#endif
#include "adnshost.h"
int rcode;
const char *config_text;
static int used, avail;
static char *buf;
void quitnow(int rc) {
if (ads) adns_finish(ads);
free(buf);
free(ov_id);
exit(rc);
}
void sysfail(const char *what, int errnoval) {
fprintf(stderr,"adnshost failed: %s: %s\n",what,strerror(errnoval));
quitnow(10);
}
void usageerr(const char *fmt, ...) {
va_list al;
fputs("adnshost usage error: ",stderr);
va_start(al,fmt);
vfprintf(stderr,fmt,al);
va_end(al);
putc('\n',stderr);
quitnow(11);
}
void outerr(void) {
sysfail("write to stdout",errno);
}
void *xmalloc(size_t sz) {
void *p;
p= malloc(sz); if (!p) sysfail("malloc",sz);
return p;
}
char *xstrsave(const char *str) {
char *p;
p= xmalloc(strlen(str)+1);
strcpy(p,str);
return p;
}
void of_config(const struct optioninfo *oi, const char *arg, const char *arg2) {
config_text= arg;
}
void of_type(const struct optioninfo *oi, const char *arg, const char *arg2) {
static const struct typename {
adns_rrtype type;
const char *desc;
} typenames[]= {
/* enhanced versions */
{ adns_r_ns, "ns" },
{ adns_r_soa, "soa" },
{ adns_r_ptr, "ptr" },
{ adns_r_mx, "mx" },
{ adns_r_rp, "rp" },
{ adns_r_addr, "addr" },
/* types with only one version */
{ adns_r_cname, "cname" },
{ adns_r_hinfo, "hinfo" },
{ adns_r_txt, "txt" },
/* raw versions */
{ adns_r_a, "a" },
{ adns_r_ns_raw, "ns-" },
{ adns_r_soa_raw, "soa-" },
{ adns_r_ptr_raw, "ptr-" },
{ adns_r_mx_raw, "mx-" },
{ adns_r_rp_raw, "rp-" },
{ adns_r_none, 0 }
};
const struct typename *tnp;
for (tnp=typenames;
tnp->type && strcmp(arg,tnp->desc);
tnp++);
if (!tnp->type) usageerr("unknown RR type %s",arg);
ov_type= tnp->type;
}
static void process_optarg(const char *arg,
const char *const **argv_p,
const char *value) {
const struct optioninfo *oip;
const char *arg2;
int invert;
if (arg[0] == '-' || arg[0] == '+') {
if (arg[0] == '-' && arg[1] == '-') {
if (!strncmp(arg,"--no-",5)) {
invert= 1;
oip= opt_findl(arg+5);
} else {
invert= 0;
oip= opt_findl(arg+2);
}
if (oip->type == ot_funcarg) {
arg= argv_p ? *++(*argv_p) : value;
if (!arg) usageerr("option --%s requires a value argument",oip->lopt);
arg2= 0;
} else if (oip->type == ot_funcarg2) {
assert(argv_p);
arg= *++(*argv_p);
arg2= arg ? *++(*argv_p) : 0;
if (!arg || !arg2)
usageerr("option --%s requires two more arguments", oip->lopt);
} else {
if (value) usageerr("option --%s does not take a value",oip->lopt);
arg= 0;
arg2= 0;
}
opt_do(oip,invert,arg,arg2);
} else if (arg[0] == '-' && arg[1] == 0) {
arg= argv_p ? *++(*argv_p) : value;
if (!arg) usageerr("option `-' must be followed by a domain");
query_do(arg);
} else { /* arg[1] != '-', != '\0' */
invert= (arg[0] == '+');
++arg;
while (*arg) {
oip= opt_finds(&arg);
if (oip->type == ot_funcarg) {
if (!*arg) {
arg= argv_p ? *++(*argv_p) : value;
if (!arg) usageerr("option -%s requires a value argument",oip->sopt);
} else {
if (value) usageerr("two values for option -%s given !",oip->sopt);
}
opt_do(oip,invert,arg,0);
arg= "";
} else {
if (value) usageerr("option -%s does not take a value",oip->sopt);
opt_do(oip,invert,0,0);
}
}
}
} else { /* arg[0] != '-' */
query_do(arg);
}
}
static void read_stdin(void) {
int anydone, r;
char *newline, *space;
anydone= 0;
while (!anydone || used) {
while (!(newline= memchr(buf,'\n',used))) {
if (used == avail) {
avail += 20; avail <<= 1;
buf= realloc(buf,avail);
if (!buf) sysfail("realloc stdin buffer",errno);
}
do {
r= read(0,buf+used,avail-used);
} while (r < 0 && errno == EINTR);
if (r == 0) {
if (used) {
/* fake up final newline */
buf[used++]= '\n';
r= 1;
} else {
ov_pipe= 0;
return;
}
}
if (r < 0) sysfail("read stdin",errno);
used += r;
}
*newline++= 0;
space= strchr(buf,' ');
if (space) *space++= 0;
process_optarg(buf,0,space);
used -= (newline-buf);
memmove(buf,newline,used);
anydone= 1;
}
}
int main(int argc, const char *const *argv) {
struct timeval *tv, tvbuf;
adns_query qu;
void *qun_v;
adns_answer *answer;
int r, maxfd;
fd_set readfds, writefds, exceptfds;
const char *arg;
ensure_adns_init();
while ((arg= *++argv)) process_optarg(arg,&argv,0);
if (!ov_pipe && !ads) usageerr("no domains given, and -f/--pipe not used; try --help");
for (;;) {
for (;;) {
qu= ov_asynch ? 0 : outstanding.head ? outstanding.head->qu : 0;
r= adns_check(ads,&qu,&answer,&qun_v);
if (r == EAGAIN) break;
if (r == ESRCH) { if (!ov_pipe) goto x_quit; else break; }
assert(!r);
query_done(qun_v,answer);
}
maxfd= 0;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&exceptfds);
if (ov_pipe) {
maxfd= 1;
FD_SET(0,&readfds);
}
tv= 0;
adns_beforeselect(ads, &maxfd, &readfds,&writefds,&exceptfds, &tv,&tvbuf,0);
ADNS_CLEAR_ERRNO;
r= select(maxfd, &readfds,&writefds,&exceptfds, tv);
ADNS_CAPTURE_ERRNO;
if (r == -1) {
ADNS_CAPTURE_ERRNO;
if (errno == EINTR) continue;
sysfail("select",errno);
}
adns_afterselect(ads, maxfd, &readfds,&writefds,&exceptfds, 0);
if (ov_pipe && FD_ISSET(0,&readfds)) read_stdin();
}
x_quit:
if (fclose(stdout)) outerr();
quitnow(rcode);
}

361
lib/3rdparty/adns/client/adh-opts.c vendored Normal file
View file

@ -0,0 +1,361 @@
/*
* adh-opts.c
* - useful general-purpose resolver client program
* option handling tables etc.
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
#endif
#include "adnshost.h"
int ov_env=1, ov_pipe=0, ov_asynch=0;
int ov_verbose= 0;
adns_rrtype ov_type= adns_r_none;
int ov_search=0, ov_qc_query=0, ov_qc_anshost=0, ov_qc_cname=1;
int ov_tcp=0, ov_cname=0, ov_format=fmt_default;
char *ov_id= 0;
struct perqueryflags_remember ov_pqfr = { 1,1,1, tm_none };
static const struct optioninfo global_options[]= {
{ ot_desconly, "global binary options:" },
{ ot_flag, "Do not look at environment variables at all",
"e", "env", &ov_env, 0 },
{ ot_flag, "Read queries on stdin instead of using args",
"f", "pipe", &ov_pipe, 1 },
{ ot_flag, "Allow answers to be reordered",
"a", "asynch", &ov_asynch, 1 },
{ ot_desconly, "answer/error output format and destination (see below):" },
{ ot_value, "Answers to stdout, errors as messages to stderr (default)",
"Fs", "fmt-simple", &ov_format, fmt_simple },
{ ot_value, "Answers and errors both to stdout in parseable format",
"Fi", "fmt-inline", &ov_format, fmt_inline },
{ ot_value, "Fully-parseable output format (default for --asynch)",
"Fa", "fmt-asynch", &ov_format, fmt_asynch },
{ ot_desconly, "global verbosity level:" },
{ ot_value, "Do not print anything to stderr",
"Vq", "quiet", &ov_verbose, adns_if_noerrprint },
{ ot_value, "Report unexpected kinds of problem only (default)",
"Vn", "no-quiet", &ov_verbose, 0 },
{ ot_value, "Debugging mode",
"Vd", "debug", &ov_verbose, adns_if_debug },
{ ot_desconly, "other global options:" },
{ ot_funcarg, "Configuration to use instead of /etc/resolv.conf",
0, "config", 0,0, of_config, "<config-text>" },
{ ot_func, "Print version number",
0, "version", 0,0, of_version },
{ ot_func, "Print usage information",
0, "help", 0,0, of_help },
{ ot_end }
};
static const struct optioninfo perquery_options[]= {
{ ot_desconly, "per-query options:" },
{ ot_funcarg, "Query type (see below)",
"t", "type", 0,0, &of_type, "type" },
{ ot_funcarg, "Do reverse query (address -> name lookup)",
"i", "ptr", 0,0, &of_ptr, "addr" },
{ ot_funcarg2, "Lookup in in-addr-like `zone' (eg MAPS RBL)",
0, "reverse", 0,0, &of_reverse, "addr","zone" },
{ ot_desconly, "per-query binary options:" },
{ ot_flag, "Use the search list",
"s", "search", &ov_search, 1 },
{ ot_flag, "Let query domains contain quote-requiring chars",
"Qq", "qc-query", &ov_qc_query, 1 },
{ ot_flag, "Let hostnames in answers contain ...",
"Qa", "qc-anshost", &ov_qc_anshost, 1 },
{ ot_flag, "Prevent CNAME target domains from containing ...",
"Qc", "qc-cname", &ov_qc_cname, 0 },
{ ot_flag, "Force use of a virtual circuit",
"u", "tcp", &ov_tcp, 1 },
{ ot_flag, "Do not display owner name in output",
"Do", "show-owner", &ov_pqfr.show_owner, 0 },
{ ot_flag, "Do not display RR type in output",
"Dt", "show-type", &ov_pqfr.show_type, 0 },
{ ot_flag, "Do not display CNAME target in output",
"Dc", "show-cname", &ov_pqfr.show_cname, 0 },
{ ot_desconly, "per-query TTL mode (NB TTL is minimum across all info in reply):" },
{ ot_value, "Show the TTL as a TTL",
"Tt", "ttl-ttl", &ov_pqfr.ttl, tm_rel },
{ ot_value, "Show the TTL as a time_t when the data might expire",
"Ta", "ttl-abs", &ov_pqfr.ttl, tm_abs },
{ ot_value, "Do not show the TTL (default)",
"Tn", "no-ttl", &ov_pqfr.ttl, tm_none },
{ ot_desconly, "per-query CNAME handling mode:" },
{ ot_value, "Call it an error if a CNAME is found",
"Cf", "cname-reject", &ov_cname, adns_qf_cname_forbid },
{ ot_value, "Allow references to CNAMEs in other RRs",
"Cl", "cname-loose", &ov_cname, adns_qf_cname_loose },
{ ot_value, "CNAME ok for query domain, but not in RRs (default)",
"Cs", "cname-ok", &ov_cname, 0 },
{ ot_desconly, "asynchronous/pipe mode options:" },
{ ot_funcarg, "Set <id>, default is decimal sequence starting 0",
0, "asynch-id", 0,0, &of_asynch_id, "id" },
{ ot_funcarg, "Cancel the query with id <id> (no error if not found)",
0, "cancel-id", 0,0, &of_cancel_id, "id" },
{ ot_end }
};
static void printusage(void) {
static const struct optioninfo *const all_optiontables[]= {
global_options, perquery_options, 0
};
const struct optioninfo *const *oiap, *oip=0;
int maxsopt, maxlopt, l;
maxsopt= maxlopt= 0;
for (oiap=all_optiontables; *oiap; oiap++) {
for (oip=*oiap; oip->type != ot_end; oip++) {
if (oip->type == ot_funcarg) continue;
if (oip->sopt) { l= strlen(oip->sopt); if (l>maxsopt) maxsopt= l; }
if (oip->lopt) {
l= strlen(oip->lopt);
if (oip->type == ot_flag && !oip->value) l+= 3;
if (l>maxlopt) maxlopt= l;
}
}
}
fputs("usage: adnshost [global-opts] [query-opts] query-domain\n"
" [[query-opts] query-domain ...]\n"
" adnshost [global-opts] [query-opts] -f|--pipe\n",
stdout);
for (oiap=all_optiontables; *oiap; oiap++) {
putchar('\n');
for (oip=*oiap; oip->type != ot_end; oip++) {
switch (oip->type) {
case ot_flag:
if (!oip->value) {
if (oip->sopt) {
printf(" +%-*s --no-%-*s %s\n",
maxsopt, oip->sopt,
maxlopt-2, oip->lopt,
oip->desc);
} else {
printf(" --no-%-*s %s\n",
maxlopt+maxsopt+1, oip->lopt,
oip->desc);
}
break;
}
case ot_value: case ot_func: /* fall through */
if (oip->sopt) {
printf(" -%-*s --%-*s %s\n",
maxsopt, oip->sopt,
maxlopt+1, oip->lopt,
oip->desc);
} else {
printf(" --%-*s %s\n",
maxlopt+maxsopt+3, oip->lopt,
oip->desc);
}
break;
case ot_funcarg:
if (oip->sopt) {
l= (maxlopt + maxsopt - 9 -
(strlen(oip->sopt) + strlen(oip->lopt) + 2*strlen(oip->argdesc)));
printf(" -%s<%s> / --%s <%s>%*s%s\n",
oip->sopt, oip->argdesc, oip->lopt, oip->argdesc,
l>2 ? l : 2, "",
oip->desc);
} else {
l= (maxlopt + maxsopt + 1 -
(strlen(oip->lopt) + strlen(oip->argdesc)));
printf(" --%s <%s>%*s%s\n",
oip->lopt, oip->argdesc,
l>2 ? l : 2, "",
oip->desc);
}
break;
case ot_funcarg2:
assert(!oip->sopt);
l= (maxlopt + maxsopt - 2 -
(strlen(oip->lopt) + strlen(oip->argdesc) + strlen(oip->argdesc2)));
printf(" --%s <%s> <%s>%*s%s\n",
oip->lopt, oip->argdesc, oip->argdesc2,
l>2 ? l : 2, "",
oip->desc);
break;
case ot_desconly:
printf("%s\n", oip->desc);
break;
default:
abort();
}
}
}
printf("\nEscaping domains which might start with `-':\n"
" - %-*s Next argument is a domain, but more options may follow\n",
maxlopt+maxsopt+3, "<domain>");
fputs("\n"
"Query domains should always be quoted according to master file format.\n"
"\n"
"For binary options, --FOO and --no-FOO are opposites, as are\n"
"-X and +X. In each case the default is the one not listed.\n"
"Per query options stay set a particular way until they are reset,\n"
"whether they appear on the command line or on stdin.\n"
"All global options must preceed the first query domain.\n"
"\n"
"With -f, the input should be lines with either an option, possibly\n"
"with a value argument (separated from the option by a space if it's a long\n"
"option), or a domain (possibly preceded by a hyphen and a space to\n"
"distinguish it from an option).\n"
"\n"
"Output format is master file format without class or TTL by default:\n"
" [<owner>] [<ttl>] [<type>] <data>\n"
"or if the <owner> domain refers to a CNAME and --show-cname is on\n"
" [<owner>] [<ttl>] CNAME <cname>\n"
" [<cname>] [<ttl>] <type> <data>\n"
"When a query fails you get an error message to stderr (with --fmt-simple).\n"
"Specify --fmt-inline for lines like this (broken here for readability):\n"
" ; failed <statustype> <statusnum> <statusabbrev> \\\n"
" [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
"If you use --fmt-asynch, which is the default for --asynch,\n"
"each answer (success or failure) is preceded by a line\n"
" <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
" [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
"where <nrrs> is the number of RRs that follow and <cname> will be `$' or\n"
"the CNAME target; the CNAME indirection and error formats above are not used.\n"
"\n"
"Exit status:\n"
" 0 all went well\n"
" 1-6 at least one query failed with statustype:\n"
" 1 localfail )\n"
" 2 remotefail ) temporary errors\n"
" 3 tempfail __)_________________\n"
" 4 misconfig )\n"
" 5 misquery ) permanent errors\n"
" 6 permfail )\n"
" 10 system trouble\n"
" 11 usage problems\n"
"\n"
"Query types (see adns.h; default is addr):\n"
" ns soa ptr mx rp addr - enhanced versions\n"
" cname hinfo txt - types with only one version\n"
" a ns- soa- ptr- mx- rp- - _raw versions\n"
"Default is addr, or ptr for -i/--ptr queries\n",
stdout);
if (ferror(stdout)) sysfail("write usage message",errno);
}
void of_version(const struct optioninfo *oi, const char *arg, const char *arg2) {
VERSION_PRINT_QUIT("adnshost");
}
void of_help(const struct optioninfo *oi, const char *arg, const char *arg2) {
printusage();
if (fclose(stdout)) sysfail("finish writing output",errno);
quitnow(0);
}
typedef int comparer_type(const char **optp, const struct optioninfo *entry);
static int oc_long(const char **optp, const struct optioninfo *entry) {
return entry->lopt && !strcmp(*optp,entry->lopt);
}
static int oc_short(const char **optp, const struct optioninfo *entry) {
const char *sopt;
int l;
sopt= entry->sopt;
if (!sopt) return 0;
l= strlen(sopt);
if (memcmp(*optp,sopt,l)) return 0;
(*optp) += l;
return 1;
}
static const struct optioninfo *find1(const char **optp,
const struct optioninfo *table,
comparer_type *comparer) {
for (;;) {
if (table->type == ot_end) return 0;
if (comparer(optp,table)) return table;
table++;
}
}
static const struct optioninfo *find(const char **optp,
const char *prefix,
comparer_type *comparer) {
const struct optioninfo *oip;
const char *opt;
opt= *optp;
oip= find1(optp,perquery_options,comparer);
if (oip) return oip;
oip= find1(optp,global_options,comparer);
if (!oip) usageerr("unknown option %s%s",prefix,opt);
if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,opt);
return oip;
}
const struct optioninfo *opt_findl(const char *opt) { return find(&opt,"--",oc_long); }
const struct optioninfo *opt_finds(const char **optp) { return find(optp,"-",oc_short); }
static void noninvert(const struct optioninfo *oip) NONRETURNING;
static void noninvert(const struct optioninfo *oip) {
usageerr("option %s%s%s%s%s may not be inverted",
oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
oip->lopt && oip->sopt ? " / " : "",
oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
}
void opt_do(const struct optioninfo *oip, int invert,
const char *arg, const char *arg2) {
switch (oip->type) {
case ot_flag:
assert(!arg);
*oip->storep= !invert;
return;
case ot_value:
assert(!arg);
if (invert) noninvert(oip);
*oip->storep= oip->value;
return;
case ot_func: case ot_funcarg: case ot_funcarg2:
if (invert) noninvert(oip);
oip->func(oip,arg,arg2);
return;
default:
abort();
}
}

315
lib/3rdparty/adns/client/adh-query.c vendored Normal file
View file

@ -0,0 +1,315 @@
/*
* adh-query.c
* - useful general-purpose resolver client program
* make queries and print answers
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
#endif
#include "adnshost.h"
adns_state ads;
struct outstanding_list outstanding;
static unsigned long idcounter;
void ensure_adns_init(void) {
adns_initflags initflags;
int r;
if (ads) return;
#ifdef SIGPIPE
if (signal(SIGPIPE,SIG_IGN) == SIG_ERR) sysfail("ignore SIGPIPE",errno);
#endif
initflags= adns_if_noautosys|adns_if_nosigpipe|ov_verbose;
if (!ov_env) initflags |= adns_if_noenv;
if (config_text) {
r= adns_init_strcfg(&ads, initflags, stderr, config_text);
} else {
r= adns_init(&ads, initflags, 0);
}
if (r) sysfail("adns_init",r);
if (ov_format == fmt_default)
ov_format= ov_asynch ? fmt_asynch : fmt_simple;
}
static void prep_query(struct query_node **qun_r, int *quflags_r) {
struct query_node *qun;
char idbuf[20];
if (ov_pipe && !ads) usageerr("-f/--pipe not consistent with domains on command line");
ensure_adns_init();
qun= malloc(sizeof(*qun));
qun->pqfr= ov_pqfr;
if (ov_id) {
qun->id= xstrsave(ov_id);
} else {
sprintf(idbuf,"%lu",idcounter++);
idcounter &= 0x0fffffffflu;
qun->id= xstrsave(idbuf);
}
*quflags_r=
(ov_search ? adns_qf_search : 0) |
(ov_tcp ? adns_qf_usevc : 0) |
((ov_pqfr.show_owner || ov_format == fmt_simple) ? adns_qf_owner : 0) |
(ov_qc_query ? adns_qf_quoteok_query : 0) |
(ov_qc_anshost ? adns_qf_quoteok_anshost : 0) |
(ov_qc_cname ? 0 : adns_qf_quoteok_cname) |
ov_cname,
*qun_r= qun;
}
void of_ptr(const struct optioninfo *oi, const char *arg, const char *arg2) {
struct query_node *qun;
int quflags, r;
struct sockaddr_in sa;
memset(&sa,0,sizeof(sa));
sa.sin_family= AF_INET;
if (!inet_aton(arg,&sa.sin_addr)) usageerr("invalid IP address %s",arg);
prep_query(&qun,&quflags);
qun->owner= xstrsave(arg);
r= adns_submit_reverse(ads,
(struct sockaddr*)&sa,
ov_type == adns_r_none ? adns_r_ptr : ov_type,
quflags,
qun,
&qun->qu);
if (r) sysfail("adns_submit_reverse",r);
LIST_LINK_TAIL(outstanding,qun);
}
void of_reverse(const struct optioninfo *oi, const char *arg, const char *arg2) {
struct query_node *qun;
int quflags, r;
struct sockaddr_in sa;
memset(&sa,0,sizeof(sa));
sa.sin_family= AF_INET;
if (!inet_aton(arg,&sa.sin_addr)) usageerr("invalid IP address %s",arg);
prep_query(&qun,&quflags);
qun->owner= xmalloc(strlen(arg) + strlen(arg2) + 2);
sprintf(qun->owner, "%s %s", arg,arg2);
r= adns_submit_reverse_any(ads,
(struct sockaddr*)&sa, arg2,
ov_type == adns_r_none ? adns_r_txt : ov_type,
quflags,
qun,
&qun->qu);
if (r) sysfail("adns_submit_reverse",r);
LIST_LINK_TAIL(outstanding,qun);
}
void query_do(const char *domain) {
struct query_node *qun;
int quflags, r;
prep_query(&qun,&quflags);
qun->owner= xstrsave(domain);
r= adns_submit(ads, domain,
ov_type == adns_r_none ? adns_r_addr : ov_type,
quflags,
qun,
&qun->qu);
if (r) sysfail("adns_submit",r);
LIST_LINK_TAIL(outstanding,qun);
}
static void dequeue_query(struct query_node *qun) {
LIST_UNLINK(outstanding,qun);
free(qun->id);
free(qun->owner);
free(qun);
}
static void print_withspace(const char *str) {
if (printf("%s ", str) == EOF) outerr();
}
static void print_ttl(struct query_node *qun, adns_answer *answer) {
unsigned long ttl;
time_t now;
switch (qun->pqfr.ttl) {
case tm_none:
return;
case tm_rel:
if (time(&now) == (time_t)-1) sysfail("get current time",errno);
ttl= answer->expires < now ? 0 : answer->expires - now;
break;
case tm_abs:
ttl= answer->expires;
break;
default:
abort();
}
if (printf("%lu ",ttl) == EOF) outerr();
}
static const char *owner_show(struct query_node *qun, adns_answer *answer) {
return answer->owner ? answer->owner : qun->owner;
}
static void print_owner_ttl(struct query_node *qun, adns_answer *answer) {
if (qun->pqfr.show_owner) print_withspace(owner_show(qun,answer));
print_ttl(qun,answer);
}
static void check_status(adns_status st) {
static const adns_status statuspoints[]= {
adns_s_ok,
adns_s_max_localfail, adns_s_max_remotefail, adns_s_max_tempfail,
adns_s_max_misconfig, adns_s_max_misquery
};
const adns_status *spp;
int minrcode;
for (minrcode=0, spp=statuspoints;
spp < statuspoints + (sizeof(statuspoints)/sizeof(statuspoints[0]));
spp++)
if (st > *spp) minrcode++;
if (rcode < minrcode) rcode= minrcode;
}
static void print_status(adns_status st, struct query_node *qun, adns_answer *answer) {
const char *statustypeabbrev, *statusabbrev, *statusstring;
statustypeabbrev= adns_errtypeabbrev(st);
statusabbrev= adns_errabbrev(st);
statusstring= adns_strerror(st);
assert(!strchr(statusstring,'"'));
if (printf("%s %d %s ", statustypeabbrev, st, statusabbrev)
== EOF) outerr();
print_owner_ttl(qun,answer);
if (qun->pqfr.show_cname)
print_withspace(answer->cname ? answer->cname : "$");
if (printf("\"%s\"\n", statusstring) == EOF) outerr();
}
static void print_dnsfail(adns_status st, struct query_node *qun, adns_answer *answer) {
int r;
const char *typename, *statusstring;
adns_status ist;
if (ov_format == fmt_inline) {
if (fputs("; failed ",stdout) == EOF) outerr();
print_status(st,qun,answer);
return;
}
assert(ov_format == fmt_simple);
if (st == adns_s_nxdomain) {
r= fprintf(stderr,"%s does not exist\n", owner_show(qun,answer));
} else {
ist= adns_rr_info(answer->type, &typename, 0,0,0,0);
if (st == adns_s_nodata) {
r= fprintf(stderr,"%s has no %s record\n", owner_show(qun,answer), typename);
} else {
statusstring= adns_strerror(st);
r= fprintf(stderr,"Error during DNS %s lookup for %s: %s\n",
typename, owner_show(qun,answer), statusstring);
}
}
if (r == EOF) sysfail("write error message to stderr",errno);
}
void query_done(struct query_node *qun, adns_answer *answer) {
adns_status st, ist;
int rrn, nrrs;
const char *rrp, *realowner, *typename;
char *datastr;
st= answer->status;
nrrs= answer->nrrs;
if (ov_format == fmt_asynch) {
check_status(st);
if (printf("%s %d ", qun->id, nrrs) == EOF) outerr();
print_status(st,qun,answer);
} else {
if (qun->pqfr.show_cname && answer->cname) {
print_owner_ttl(qun,answer);
if (qun->pqfr.show_type) print_withspace("CNAME");
if (printf("%s\n", answer->cname) == EOF) outerr();
}
if (st) {
check_status(st);
print_dnsfail(st,qun,answer);
}
}
if (qun->pqfr.show_owner) {
realowner= answer->cname ? answer->cname : owner_show(qun,answer);
assert(realowner);
} else {
realowner= 0;
}
if (nrrs) {
for (rrn=0, rrp = answer->rrs.untyped;
rrn < nrrs;
rrn++, rrp += answer->rrsz) {
if (realowner) print_withspace(realowner);
print_ttl(qun,answer);
ist= adns_rr_info(answer->type, &typename, 0, 0, rrp, &datastr);
if (ist == adns_s_nomemory) sysfail("adns_rr_info failed",ENOMEM);
assert(!ist);
if (qun->pqfr.show_type) print_withspace(typename);
if (printf("%s\n",datastr) == EOF) outerr();
free(datastr);
}
}
if (fflush(stdout)) outerr();
free(answer);
dequeue_query(qun);
}
void of_asynch_id(const struct optioninfo *oi, const char *arg, const char *arg2) {
free(ov_id);
ov_id= xstrsave(arg);
}
void of_cancel_id(const struct optioninfo *oi, const char *arg, const char *arg2) {
struct query_node *qun;
for (qun= outstanding.head;
qun && strcmp(qun->id,arg);
qun= qun->next);
if (!qun) return;
adns_cancel(qun->qu);
dequeue_query(qun);
}

125
lib/3rdparty/adns/client/adnshost.h vendored Normal file
View file

@ -0,0 +1,125 @@
/*
* adnshost.h
* - useful general-purpose resolver client program, header file
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef ADNSHOST_H_INCLUDED
#define ADNSHOST_H_INCLUDED
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#ifndef ADNS_JGAA_WIN32
# include <sys/types.h>
# include <sys/socket.h>
# include <netinet/in.h>
# include <arpa/inet.h>
#endif
#include "config.h"
#include "adns.h"
#include "dlist.h"
#include "client.h"
#ifdef ADNS_REGRESS_TEST
# include "hredirect.h"
#endif
/* declarations related to option processing */
struct optioninfo;
typedef void optfunc(const struct optioninfo *oi, const char *arg, const char *arg2);
struct optioninfo {
enum oi_type {
ot_end, ot_desconly,
ot_flag, ot_value, ot_func, ot_funcarg, ot_funcarg2
} type;
const char *desc;
const char *sopt, *lopt;
int *storep, value;
optfunc *func;
const char *argdesc, *argdesc2;
};
enum ttlmode { tm_none, tm_rel, tm_abs };
enum outputformat { fmt_default, fmt_simple, fmt_inline, fmt_asynch };
struct perqueryflags_remember {
int show_owner, show_type, show_cname;
int ttl;
};
extern int ov_env, ov_pipe, ov_asynch;
extern int ov_verbose;
extern adns_rrtype ov_type;
extern int ov_search, ov_qc_query, ov_qc_anshost, ov_qc_cname;
extern int ov_tcp, ov_cname, ov_format;
extern char *ov_id;
extern struct perqueryflags_remember ov_pqfr;
extern optfunc of_config, of_version, of_help, of_type, of_ptr, of_reverse;
extern optfunc of_asynch_id, of_cancel_id;
const struct optioninfo *opt_findl(const char *opt);
const struct optioninfo *opt_finds(const char **optp);
void opt_do(const struct optioninfo *oip, int invert, const char *arg, const char *arg2);
/* declarations related to query processing */
struct query_node {
struct query_node *next, *back;
struct perqueryflags_remember pqfr;
char *id, *owner;
adns_query qu;
};
extern adns_state ads;
extern struct outstanding_list { struct query_node *head, *tail; } outstanding;
void ensure_adns_init(void);
void query_do(const char *domain);
void query_done(struct query_node *qun, adns_answer *answer);
/* declarations related to main program and useful utility functions */
void sysfail(const char *what, int errnoval) NONRETURNING;
void usageerr(const char *what, ...) NONRETURNPRINTFFORMAT(1,2);
void outerr(void) NONRETURNING;
void *xmalloc(size_t sz);
char *xstrsave(const char *str);
extern int rcode;
extern const char *config_text; /* 0 => use defaults */
#endif

313
lib/3rdparty/adns/client/adnslogres.c vendored Normal file
View file

@ -0,0 +1,313 @@
/*
* adnslogres.c
* - a replacement for the Apache logresolve program using adns
*/
/*
* This file is
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
* Copyright (C) 1999-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* This version was originally supplied by Tony Finch, but has been
* modified by Ian Jackson as it was incorporated into adns and
* subsequently.
*/
static const char * const cvsid =
"$Id$";
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
# include "getopt.h"
#else
# include <sys/types.h>
# include <sys/time.h>
# include <unistd.h>
# include <string.h>
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include <errno.h>
# include <stdarg.h>
#endif
#include "config.h"
#include "adns.h"
#include "client.h"
#ifdef ADNS_REGRESS_TEST
# include "hredirect.h"
#endif
/* maximum number of concurrent DNS queries */
#define MAXMAXPENDING 64000
#define DEFMAXPENDING 2000
/* maximum length of a line */
#define MAXLINE 1024
/* option flags */
#define OPT_DEBUG 1
#ifdef HAVE_POLL
# define OPT_POLL 2
#endif
static const char *const progname= "adnslogres";
static const char *config_text;
#define guard_null(str) ((str) ? (str) : "")
#define sensible_ctype(type,ch) (type((unsigned char)(ch)))
/* isfoo() functions from ctype.h can't safely be fed char - blech ! */
static void msg(const char *fmt, ...) {
va_list al;
fprintf(stderr, "%s: ", progname);
va_start(al,fmt);
vfprintf(stderr, fmt, al);
va_end(al);
fputc('\n',stderr);
}
static void aargh(const char *cause) {
const char *why = strerror(errno);
if (!why) why = "Unknown error";
msg("%s: %s (%d)", cause, why, errno);
exit(1);
}
/*
* Parse the IP address and convert to a reverse domain name.
*/
static char *ipaddr2domain(char *start, char **addr, char **rest) {
static char buf[30]; /* "123.123.123.123.in-addr.arpa.\0" */
char *ptrs[5];
int i;
ptrs[0]= start;
retry:
while (!sensible_ctype(isdigit,*ptrs[0]))
if (!*ptrs[0]++) {
strcpy(buf, "invalid.");
*addr= *rest= NULL;
return buf;
}
for (i= 1; i < 5; i++) {
ptrs[i]= ptrs[i-1];
while (sensible_ctype(isdigit,*ptrs[i]++));
if ((i == 4 && !sensible_ctype(isspace,ptrs[i][-1])) ||
(i != 4 && ptrs[i][-1] != '.') ||
(ptrs[i]-ptrs[i-1] > 4)) {
ptrs[0]= ptrs[i]-1;
goto retry;
}
}
sprintf(buf, "%.*s.%.*s.%.*s.%.*s.in-addr.arpa.",
ptrs[4]-ptrs[3]-1, ptrs[3],
ptrs[3]-ptrs[2]-1, ptrs[2],
ptrs[2]-ptrs[1]-1, ptrs[1],
ptrs[1]-ptrs[0]-1, ptrs[0]);
*addr= ptrs[0];
*rest= ptrs[4]-1;
return buf;
}
static void printline(FILE *outf, char *start, char *addr, char *rest, char *domain) {
if (domain)
fprintf(outf, "%.*s%s%s", addr - start, start, domain, rest);
else
fputs(start, outf);
if (ferror(outf)) aargh("write output");
}
typedef struct logline {
struct logline *next;
char *start, *addr, *rest;
adns_query query;
} logline;
static logline *readline(FILE *inf, adns_state adns, int opts) {
static char buf[MAXLINE];
char *str;
logline *line;
if (fgets(buf, MAXLINE, inf)) {
str= malloc(sizeof(*line) + strlen(buf) + 1);
if (!str) aargh("malloc");
line= (logline*)str;
line->next= NULL;
line->start= str+sizeof(logline);
strcpy(line->start, buf);
str= ipaddr2domain(line->start, &line->addr, &line->rest);
if (opts & OPT_DEBUG)
msg("submitting %.*s -> %s", line->rest-line->addr, guard_null(line->addr), str);
if (adns_submit(adns, str, adns_r_ptr,
adns_qf_quoteok_cname|adns_qf_cname_loose,
NULL, &line->query))
aargh("adns_submit");
return line;
}
if (!feof(inf))
aargh("fgets");
return NULL;
}
static void proclog(FILE *inf, FILE *outf, int maxpending, int opts) {
int eof, err, len;
adns_state adns;
adns_answer *answer;
logline *head, *tail, *line;
adns_initflags initflags;
initflags= (opts & OPT_DEBUG) ? adns_if_debug : 0;
if (config_text) {
errno= adns_init_strcfg(&adns, initflags, stderr, config_text);
} else {
errno= adns_init(&adns, initflags, 0);
}
if (errno) aargh("adns_init");
head= tail= readline(inf, adns, opts);
len= 1; eof= 0;
while (head) {
while (head) {
if (opts & OPT_DEBUG)
msg("%d in queue; checking %.*s", len,
head->rest-head->addr, guard_null(head->addr));
if (eof || len >= maxpending) {
#ifdef HAVE_POLL
if (opts & OPT_POLL)
err= adns_wait_poll(adns, &head->query, &answer, NULL);
else
#endif
err= adns_wait(adns, &head->query, &answer, NULL);
} else {
err= adns_check(adns, &head->query, &answer, NULL);
}
if (err == EAGAIN) break;
if (err) {
fprintf(stderr, "%s: adns_wait/check: %s", progname, strerror(err));
exit(1);
}
printline(outf, head->start, head->addr, head->rest,
answer->status == adns_s_ok ? *answer->rrs.str : NULL);
line= head; head= head->next;
free(line);
free(answer);
len--;
}
if (!eof) {
line= readline(inf, adns, opts);
if (line) {
if (!head) head= line;
else tail->next= line;
tail= line; len++;
} else {
eof= 1;
}
}
}
adns_finish(adns);
}
static void printhelp(FILE *file) {
fputs("usage: adnslogres [<options>] [<logfile>]\n"
" adnslogres --version|--help\n"
"options: -c <concurrency> set max number of outstanding queries\n"
#ifdef HAVE_POLL
" -p use poll(2) instead of select(2)\n"
#endif
" -d turn on debugging\n"
" -C <config> use instead of contents of resolv.conf\n",
stdout);
}
static void usage(void) {
printhelp(stderr);
exit(1);
}
int main(int argc, char *argv[]) {
int c, opts, maxpending;
extern char *optarg;
FILE *inf;
if (argv[1] && !strncmp(argv[1],"--",2)) {
if (!strcmp(argv[1],"--help")) {
printhelp(stdout);
} else if (!strcmp(argv[1],"--version")) {
fputs(VERSION_MESSAGE("adnslogres"),stdout);
} else {
usage();
}
if (ferror(stdout) || fclose(stdout)) { perror("stdout"); exit(1); }
exit(0);
}
maxpending= DEFMAXPENDING;
opts= 0;
while ((c= getopt(argc, argv, "c:C:dp")) != -1)
switch (c) {
case 'c':
maxpending= atoi(optarg);
if (maxpending < 1 || maxpending > MAXMAXPENDING) {
fprintf(stderr, "%s: unfeasible concurrency %d\n", progname, maxpending);
exit(1);
}
break;
case 'C':
config_text= optarg;
break;
case 'd':
opts|= OPT_DEBUG;
break;
#ifdef HAVE_POLL
case 'p':
opts|= OPT_POLL;
break;
#endif
default:
usage();
}
argc-= optind;
argv+= optind;
inf= NULL;
if (argc == 0)
inf= stdin;
else if (argc == 1)
inf= fopen(*argv, "r");
else
usage();
if (!inf)
aargh("couldn't open input");
proclog(inf, stdout, maxpending, opts);
if (fclose(inf))
aargh("fclose input");
if (fclose(stdout))
aargh("fclose output");
return 0;
}

477
lib/3rdparty/adns/client/adnsresfilter.c vendored Normal file
View file

@ -0,0 +1,477 @@
/*
* adnsresfilter.c
* - filter which does resolving, not part of the library
*/
/*
* This file is
* Copyright (C) 1999-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <search.h>
#include <assert.h>
#include <ctype.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include "config.h"
#include "adns.h"
#include "dlist.h"
#include "tvarith.h"
#include "client.h"
#ifdef ADNS_REGRESS_TEST
# include "hredirect.h"
#endif
struct outqueuenode {
struct outqueuenode *next, *back;
void *buffer;
char *textp;
int textlen;
struct timeval printbefore;
struct treething *addr;
};
static int bracket, forever, address;
static unsigned long timeout= 1000;
static adns_rrtype rrt= adns_r_ptr;
static adns_initflags initflags= 0;
static const char *config_text;
static int outblocked, inputeof;
static struct { struct outqueuenode *head, *tail; } outqueue;
static int peroutqueuenode, outqueuelen;
static struct sockaddr_in sa;
static adns_state ads;
static char addrtextbuf[14];
static int cbyte, inbyte, inbuf;
static unsigned char bytes[4];
static struct timeval printbefore;
struct treething {
unsigned char bytes[4];
adns_query qu;
adns_answer *ans;
};
static struct treething *newthing;
static void *treeroot;
static int nonblock(int fd, int isnonblock) {
int r;
r= fcntl(fd,F_GETFL);
if (r==-1) return -1;
r= fcntl(fd,F_SETFL, isnonblock ? r|O_NONBLOCK : r&~O_NONBLOCK);
if (r==-1) return -1;
return 0;
}
void quitnow(int exitstatus) {
nonblock(0,0);
nonblock(1,0);
exit(exitstatus);
}
static void sysfail(const char *what) NONRETURNING;
static void sysfail(const char *what) {
fprintf(stderr,"adnsresfilter: system call failed: %s: %s\n",what,strerror(errno));
quitnow(2);
}
static void *xmalloc(size_t sz) {
void *r;
r= malloc(sz); if (r) return r;
sysfail("malloc");
}
static void outputerr(void) NONRETURNING;
static void outputerr(void) { sysfail("write to stdout"); }
static void usage(void) {
if (printf("usage: adnsresfilter [<options ...>]\n"
" adnsresfilter -h|--help | --version\n"
"options: -t<milliseconds>|--timeout <milliseconds>\n"
" -w|--wait (always wait for queries to time out or fail)\n"
" -b|--brackets (require [...] around IP addresses)\n"
" -a|--address (always include [address] in output)\n"
" -u|--unchecked (do not forward map for checking)\n"
" --config <text> (use this instead of resolv.conf)\n"
" --debug (turn on adns resolver debugging)\n"
"Timeout is the maximum amount to delay any particular bit of output for.\n"
"Lookups will go on in the background. Default timeout = 1000 (ms).\n")
== EOF) outputerr();
if (fflush(stdout)) sysfail("flush stdout");
}
static void usageerr(const char *why) NONRETURNING;
static void usageerr(const char *why) {
fprintf(stderr,"adnsresfilter: bad usage: %s\n",why);
usage();
quitnow(1);
}
static void adnsfail(const char *what, int e) NONRETURNING;
static void adnsfail(const char *what, int e) {
fprintf(stderr,"adnsresfilter: adns call failed: %s: %s\n",what,strerror(e));
quitnow(2);
}
static void settimeout(const char *arg) {
char *ep;
timeout= strtoul(arg,&ep,0);
if (*ep) usageerr("invalid timeout");
}
static void parseargs(const char *const *argv) {
const char *arg;
int c;
while ((arg= *++argv)) {
if (arg[0] != '-') usageerr("no non-option arguments are allowed");
if (arg[1] == '-') {
if (!strcmp(arg,"--timeout")) {
if (!(arg= *++argv)) usageerr("--timeout needs a value");
settimeout(arg);
forever= 0;
} else if (!strcmp(arg,"--wait")) {
forever= 1;
} else if (!strcmp(arg,"--brackets")) {
bracket= 1;
} else if (!strcmp(arg,"--address")) {
address= 1;
} else if (!strcmp(arg,"--unchecked")) {
rrt= adns_r_ptr_raw;
} else if (!strcmp(arg,"--config")) {
if (!(arg= *++argv)) usageerr("--config needs a value");
config_text= arg;
} else if (!strcmp(arg,"--debug")) {
initflags |= adns_if_debug;
} else if (!strcmp(arg,"--help")) {
usage(); quitnow(0);
} else if (!strcmp(arg,"--version")) {
VERSION_PRINT_QUIT("adnsresfilter"); quitnow(0);
} else {
usageerr("unknown long option");
}
} else {
while ((c= *++arg)) {
switch (c) {
case 't':
if (*++arg) settimeout(arg);
else if ((arg= *++argv)) settimeout(arg);
else usageerr("-t needs a value");
forever= 0;
arg= "\0";
break;
case 'w':
forever= 1;
break;
case 'b':
bracket= 1;
break;
case 'a':
address= 1;
break;
case 'u':
rrt= adns_r_ptr_raw;
break;
case 'h':
usage();
quitnow(0);
default:
usageerr("unknown short option");
}
}
}
}
}
static void queueoutchar(int c) {
struct outqueuenode *entry;
entry= outqueue.tail;
if (!entry || entry->addr || entry->textlen >= peroutqueuenode) {
peroutqueuenode= !peroutqueuenode || !entry || entry->addr ? 128 :
peroutqueuenode >= 1024 ? 4096 : peroutqueuenode<<2;
entry= xmalloc(sizeof(*entry));
entry->buffer= xmalloc(peroutqueuenode);
entry->textp= entry->buffer;
entry->textlen= 0;
entry->addr= 0;
LIST_LINK_TAIL(outqueue,entry);
outqueuelen++;
}
entry->textp[entry->textlen++]= c;
}
static void queueoutstr(const char *str, int len) {
while (len-- > 0) queueoutchar(*str++);
}
static void writestdout(struct outqueuenode *entry) {
int r;
while (entry->textlen) {
r= write(1, entry->textp, entry->textlen);
if (r < 0) {
if (errno == EINTR) continue;
if (errno == EAGAIN) { outblocked= 1; break; }
sysfail("write stdout");
}
assert(r <= entry->textlen);
entry->textp += r;
entry->textlen -= r;
}
if (!entry->textlen) {
LIST_UNLINK(outqueue,entry);
free(entry->buffer);
free(entry);
outqueuelen--;
}
}
static void replacetextwithname(struct outqueuenode *entry) {
char *name, *newbuf;
int namelen, newlen;
name= entry->addr->ans->rrs.str[0];
namelen= strlen(name);
if (!address) {
free(entry->buffer);
entry->buffer= 0;
entry->textp= name;
entry->textlen= namelen;
} else {
newlen= entry->textlen + namelen + (bracket ? 0 : 2);
newbuf= xmalloc(newlen + 1);
sprintf(newbuf, bracket ? "%s%.*s" : "%s[%.*s]", name, entry->textlen, entry->textp);
free(entry->buffer);
entry->buffer= entry->textp= newbuf;
entry->textlen= newlen;
}
}
static void checkadnsqueries(void) {
adns_query qu;
adns_answer *ans;
void *context;
struct treething *foundthing;
int r;
for (;;) {
qu= 0; context= 0; ans= 0;
r= adns_check(ads,&qu,&ans,&context);
if (r == ESRCH || r == EAGAIN) break;
assert(!r);
foundthing= context;
foundthing->ans= ans;
foundthing->qu= 0;
}
}
static void restartbuf(void) {
if (inbuf>0) queueoutstr(addrtextbuf,inbuf);
inbuf= 0;
}
static int comparer(const void *a, const void *b) {
return memcmp(a,b,4);
}
static void procaddr(void) {
struct treething *foundthing;
void **searchfound;
struct outqueuenode *entry;
int r;
if (!newthing) {
newthing= xmalloc(sizeof(struct treething));
newthing->qu= 0;
newthing->ans= 0;
}
memcpy(newthing->bytes,bytes,4);
searchfound= tsearch(newthing,&treeroot,comparer);
if (!searchfound) sysfail("tsearch");
foundthing= *searchfound;
if (foundthing == newthing) {
newthing= 0;
memcpy(&sa.sin_addr,bytes,4);
r= adns_submit_reverse(ads, (const struct sockaddr*)&sa,
rrt,0,foundthing,&foundthing->qu);
if (r) adnsfail("submit",r);
}
entry= xmalloc(sizeof(*entry));
entry->buffer= xmalloc(inbuf);
entry->textp= entry->buffer;
memcpy(entry->textp,addrtextbuf,inbuf);
entry->textlen= inbuf;
entry->addr= foundthing;
entry->printbefore= printbefore;
LIST_LINK_TAIL(outqueue,entry);
outqueuelen++;
inbuf= 0;
cbyte= -1;
}
static void startaddr(void) {
bytes[cbyte=0]= 0;
inbyte= 0;
}
static void readstdin(void) {
char readbuf[512], *p;
int r, c, nbyte;
while ((r= read(0,readbuf,sizeof(readbuf))) <= 0) {
if (r == 0) { inputeof= 1; return; }
if (r == EAGAIN) return;
if (r != EINTR) sysfail("read stdin");
}
for (p=readbuf; r>0; r--,p++) {
c= *p;
if (cbyte==-1 && bracket && c=='[') {
addrtextbuf[inbuf++]= c;
startaddr();
} else if (cbyte==-1 && !bracket && !isalnum(c)) {
queueoutchar(c);
startaddr();
} else if (cbyte>=0 && inbyte<3 && c>='0' && c<='9' &&
(nbyte= bytes[cbyte]*10 + (c-'0')) <= 255) {
bytes[cbyte]= nbyte;
addrtextbuf[inbuf++]= c;
inbyte++;
} else if (cbyte>=0 && cbyte<3 && inbyte>0 && c=='.') {
bytes[++cbyte]= 0;
addrtextbuf[inbuf++]= c;
inbyte= 0;
} else if (cbyte==3 && inbyte>0 && bracket && c==']') {
addrtextbuf[inbuf++]= c;
procaddr();
} else if (cbyte==3 && inbyte>0 && !bracket && !isalnum(c)) {
procaddr();
queueoutchar(c);
startaddr();
} else {
restartbuf();
queueoutchar(c);
cbyte= -1;
if (!bracket && !isalnum(c)) startaddr();
}
}
}
static void startup(void) {
int r;
if (nonblock(0,1)) sysfail("set stdin to nonblocking mode");
if (nonblock(1,1)) sysfail("set stdout to nonblocking mode");
memset(&sa,0,sizeof(sa));
sa.sin_family= AF_INET;
if (config_text) {
r= adns_init_strcfg(&ads,initflags,stderr,config_text);
} else {
r= adns_init(&ads,initflags,0);
}
if (r) adnsfail("init",r);
cbyte= -1;
inbyte= -1;
inbuf= 0;
if (!bracket) startaddr();
}
int main(int argc, const char *const *argv) {
int r, maxfd;
fd_set readfds, writefds, exceptfds;
struct outqueuenode *entry;
struct timeval *tv, tvbuf, now;
parseargs(argv);
startup();
while (!inputeof || outqueue.head) {
maxfd= 2;
tv= 0;
FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
if ((entry= outqueue.head) && !outblocked) {
if (!entry->addr) {
writestdout(entry);
continue;
}
if (entry->addr->ans) {
if (entry->addr->ans->nrrs)
replacetextwithname(entry);
entry->addr= 0;
continue;
}
r= gettimeofday(&now,0); if (r) sysfail("gettimeofday");
if (forever) {
tv= 0;
} else if (!timercmp(&now,&entry->printbefore,<)) {
entry->addr= 0;
continue;
} else {
tvbuf.tv_sec= entry->printbefore.tv_sec - now.tv_sec - 1;
tvbuf.tv_usec= entry->printbefore.tv_usec - now.tv_usec + 1000000;
tvbuf.tv_sec += tvbuf.tv_usec / 1000000;
tvbuf.tv_usec %= 1000000;
tv= &tvbuf;
}
adns_beforeselect(ads,&maxfd,&readfds,&writefds,&exceptfds,
&tv,&tvbuf,&now);
}
if (outblocked) FD_SET(1,&writefds);
if (!inputeof && outqueuelen<1024) FD_SET(0,&readfds);
ADNS_CLEAR_ERRNO;
r= select(maxfd,&readfds,&writefds,&exceptfds,tv);
ADNS_CAPTURE_ERRNO;
if (r < 0) { if (r == EINTR) continue; else sysfail("select"); }
r= gettimeofday(&now,0); if (r) sysfail("gettimeofday");
adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,&now);
checkadnsqueries();
if (FD_ISSET(0,&readfds)) {
if (!forever) {
printbefore= now;
timevaladd(&printbefore,timeout);
}
readstdin();
} else if (FD_ISSET(1,&writefds)) {
outblocked= 0;
}
}
if (nonblock(0,0)) sysfail("un-nonblock stdin");
if (nonblock(1,0)) sysfail("un-nonblock stdout");
adns_finish(ads);
exit(0);
}

346
lib/3rdparty/adns/client/adnstest.c vendored Normal file
View file

@ -0,0 +1,346 @@
/*
* adnstest.c
* - simple test program, not part of the library
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
#else
# include <stdio.h>
# include <sys/time.h>
# include <unistd.h>
# include <assert.h>
# include <stdlib.h>
# include <string.h>
# include <errno.h>
#endif
#include "config.h"
#include "adns.h"
#ifdef ADNS_REGRESS_TEST
# include "hredirect.h"
#endif
struct myctx {
adns_query qu;
int doneyet, found;
const char *fdom;
};
static struct myctx *mcs;
static adns_state ads;
static adns_rrtype *types_a;
static void quitnow(int rc) NONRETURNING;
static void quitnow(int rc) {
free(mcs);
free(types_a);
if (ads) adns_finish(ads);
exit(rc);
}
#ifndef HAVE_POLL
#undef poll
int poll(struct pollfd *ufds, int nfds, int timeout) {
fputs("poll(2) not supported on this system\n",stderr);
quitnow(5);
return -1; /* compiler food */
}
#define adns_beforepoll(a,b,c,d,e) 0
#define adns_afterpoll(a,b,c,d) 0
#endif
static void failure_status(const char *what, adns_status st) NONRETURNING;
static void failure_status(const char *what, adns_status st) {
fprintf(stderr,"adns failure: %s: %s\n",what,adns_strerror(st));
quitnow(2);
}
static void failure_errno(const char *what, int errnoval) NONRETURNING;
static void failure_errno(const char *what, int errnoval) {
fprintf(stderr,"adns failure: %s: errno=%d\n",what,errnoval);
quitnow(2);
}
static void usageerr(const char *why) NONRETURNING;
static void usageerr(const char *why) {
fprintf(stderr,
"bad usage: %s\n"
"usage: adnstest [-<initflagsnum>[,<owninitflags>]] [/<initstring>]\n"
" [ :<typenum>,... ]\n"
" [ [<queryflagsnum>[,<ownqueryflags>]/]<domain> ... ]\n"
"initflags: p use poll(2) instead of select(2)\n"
" s use adns_wait with specified query, instead of 0\n"
"queryflags: a print status abbrevs instead of strings\n"
"exit status: 0 ok (though some queries may have failed)\n"
" 1 used by test harness to indicate test failed\n"
" 2 unable to submit or init or some such\n"
" 3 unexpected failure\n"
" 4 usage error\n"
" 5 operation not supported on this system\n",
why);
quitnow(4);
}
static const adns_rrtype defaulttypes[]= {
adns_r_a,
adns_r_ns_raw,
adns_r_cname,
adns_r_soa_raw,
adns_r_ptr_raw,
adns_r_hinfo,
adns_r_mx_raw,
adns_r_txt,
adns_r_rp_raw,
adns_r_addr,
adns_r_ns,
adns_r_ptr,
adns_r_mx,
adns_r_soa,
adns_r_rp,
adns_r_none
};
static void dumptype(adns_status ri, const char *rrtn, const char *fmtn) {
fprintf(stdout, "%s(%s)%s%s",
ri ? "?" : rrtn, ri ? "?" : fmtn ? fmtn : "-",
ri ? " " : "", ri ? adns_strerror(ri) : "");
}
static void fdom_split(const char *fdom, const char **dom_r, int *qf_r,
char *ownflags, int ownflags_l) {
int qf;
char *ep;
qf= strtoul(fdom,&ep,0);
if (*ep == ',' && strchr(ep,'/')) {
ep++;
while (*ep != '/') {
if (--ownflags_l <= 0) { fputs("too many flags\n",stderr); quitnow(3); }
*ownflags++= *ep++;
}
}
if (*ep != '/') { *dom_r= fdom; *qf_r= 0; }
else { *dom_r= ep+1; *qf_r= qf; }
*ownflags= 0;
}
static int consistsof(const char *string, const char *accept) {
return strspn(string,accept) == strlen(string);
}
int main(int argc, char *const *argv) {
adns_query qu;
struct myctx *mc, *mcw;
void *mcr;
adns_answer *ans;
const char *initstring, *rrtn, *fmtn;
const char *const *fdomlist, *domain;
char *show, *cp;
int len, i, qc, qi, tc, ti, ch, qflags, initflagsnum;
adns_status ri;
int r;
const adns_rrtype *types;
struct timeval now;
char ownflags[10];
char *ep;
const char *initflags, *owninitflags;
if (argv[0] && argv[1] && argv[1][0] == '-') {
initflags= argv[1]+1;
argv++;
} else {
initflags= "";
}
if (argv[0] && argv[1] && argv[1][0] == '/') {
initstring= argv[1]+1;
argv++;
} else {
initstring= 0;
}
initflagsnum= strtoul(initflags,&ep,0);
if (*ep == ',') {
owninitflags= ep+1;
if (!consistsof(owninitflags,"ps")) usageerr("unknown owninitflag");
} else if (!*ep) {
owninitflags= "";
} else {
usageerr("bad <initflagsnum>[,<owninitflags>]");
}
if (argv[0] && argv[1] && argv[1][0] == ':') {
for (cp= argv[1]+1, tc=1; (ch= *cp); cp++)
if (ch==',') tc++;
types_a= malloc(sizeof(*types_a)*(tc+1));
if (!types_a) { perror("malloc types"); quitnow(3); }
for (cp= argv[1]+1, ti=0; ti<tc; ti++) {
types_a[ti]= strtoul(cp,&cp,10);
if ((ch= *cp)) {
if (ch != ',') usageerr("unexpected char (not comma) in or between types");
cp++;
}
}
types_a[ti]= adns_r_none;
types= types_a;
argv++;
} else {
types_a= 0;
types= defaulttypes;
}
if (!(argv[0] && argv[1])) usageerr("no query domains supplied");
fdomlist= (const char *const*)argv+1;
for (qc=0; fdomlist[qc]; qc++);
for (tc=0; types[tc] != adns_r_none; tc++);
mcs= malloc(tc ? sizeof(*mcs)*qc*tc : 1);
if (!mcs) { perror("malloc mcs"); quitnow(3); }
setvbuf(stdout,0,_IOLBF,0);
if (initstring) {
r= adns_init_strcfg(&ads,
(adns_if_debug|adns_if_noautosys|adns_if_checkc_freq)
^initflagsnum,
stdout,initstring);
} else {
r= adns_init(&ads,
(adns_if_debug|adns_if_noautosys)^initflagsnum,
0);
}
if (r) failure_errno("init",r);
for (qi=0; qi<qc; qi++) {
fdom_split(fdomlist[qi],&domain,&qflags,ownflags,sizeof(ownflags));
if (!consistsof(ownflags,"a")) usageerr("unknown ownqueryflag");
for (ti=0; ti<tc; ti++) {
mc= &mcs[qi*tc+ti];
mc->doneyet= 0;
mc->fdom= fdomlist[qi];
fprintf(stdout,"%s flags %d type %d",domain,qflags,types[ti]);
r= adns_submit(ads,domain,types[ti],qflags,mc,&mc->qu);
if (r == ENOSYS) {
fprintf(stdout," not implemented\n");
mc->qu= 0;
mc->doneyet= 1;
} else if (r) {
failure_errno("submit",r);
} else {
ri= adns_rr_info(types[ti], &rrtn,&fmtn,0, 0,0);
putc(' ',stdout);
dumptype(ri,rrtn,fmtn);
fprintf(stdout," submitted\n");
}
}
}
for (;;) {
for (qi=0; qi<qc; qi++) {
for (ti=0; ti<tc; ti++) {
mc= &mcs[qi*tc+ti];
mc->found= 0;
}
}
for (adns_forallqueries_begin(ads);
(qu= adns_forallqueries_next(ads,&mcr));
) {
mc= mcr;
assert(qu == mc->qu);
assert(!mc->doneyet);
mc->found= 1;
}
mcw= 0;
for (qi=0; qi<qc; qi++) {
for (ti=0; ti<tc; ti++) {
mc= &mcs[qi*tc+ti];
if (mc->doneyet) continue;
assert(mc->found);
if (!mcw) mcw= mc;
}
}
if (!mcw) break;
if (strchr(owninitflags,'s')) {
qu= mcw->qu;
mc= mcw;
} else {
qu= 0;
mc= 0;
}
#ifdef HAVE_POLL
if (strchr(owninitflags,'p')) {
r= adns_wait_poll(ads,&qu,&ans,&mcr);
} else
#endif
{
r= adns_wait(ads,&qu,&ans,&mcr);
}
if (r) failure_errno("wait/check",r);
if (mc) assert(mcr==mc);
else mc= mcr;
assert(qu==mc->qu);
assert(!mc->doneyet);
fdom_split(mc->fdom,&domain,&qflags,ownflags,sizeof(ownflags));
if (gettimeofday(&now,0)) { perror("gettimeofday"); quitnow(3); }
ri= adns_rr_info(ans->type, &rrtn,&fmtn,&len, 0,0);
fprintf(stdout, "%s flags %d type ",domain,qflags);
dumptype(ri,rrtn,fmtn);
fprintf(stdout, "%s%s: %s; nrrs=%d; cname=%s; owner=%s; ttl=%ld\n",
ownflags[0] ? " ownflags=" : "", ownflags,
strchr(ownflags,'a')
? adns_errabbrev(ans->status)
: adns_strerror(ans->status),
ans->nrrs,
ans->cname ? ans->cname : "$",
ans->owner ? ans->owner : "$",
(long)ans->expires - (long)now.tv_sec);
if (ans->nrrs) {
assert(!ri);
for (i=0; i<ans->nrrs; i++) {
ri= adns_rr_info(ans->type, 0,0,0, ans->rrs.bytes + i*len, &show);
if (ri) failure_status("info",ri);
fprintf(stdout," %s\n",show);
free(show);
}
}
free(ans);
mc->doneyet= 1;
}
quitnow(0);
}

52
lib/3rdparty/adns/client/client.h vendored Normal file
View file

@ -0,0 +1,52 @@
/*
* clients.h
* - useful declarations and definitions for adns client programs
*/
/*
* This file is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef CLIENT_H_INCLUDED
#define CLIENT_H_INCLUDED
#define ADNS_VERSION_STRING "1.0"
#define COPYRIGHT_MESSAGE \
"Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>\n" \
"Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>\n" \
"This is free software; see the source for copying conditions. There is NO\n" \
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
#define VERSION_MESSAGE(program) \
program " (GNU adns) " ADNS_VERSION_STRING "\n\n" COPYRIGHT_MESSAGE
#define VERSION_PRINT_QUIT(program) \
if (fputs(VERSION_MESSAGE(program),stdout) == EOF || \
fclose(stdout)) { \
perror(program ": write version message"); \
quitnow(-1); \
} \
quitnow(0);
void quitnow(int rc) NONRETURNING;
#endif

89
lib/3rdparty/adns/client/fanftest.c vendored Normal file
View file

@ -0,0 +1,89 @@
/*
* fanftest.c
* - a small test program from Tony Finch
*/
/*
* This file is
* Copyright (C) 1999 Tony Finch <dot@dotat.at>
* Copyright (C) 1999-2000 Ian Jackson <ian@davenant.greenend.org.uk>
*
* It is part of adns, which is
* Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
* Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
*
* 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* This version was originally supplied by Tony Finch, but has been
* modified by Ian Jackson as it was incorporated into adns.
*/
static const char * const cvsid =
"$Id$";
#ifdef ADNS_JGAA_WIN32
# include "adns_win32.h"
#else
# include <sys/types.h>
# include <sys/time.h>
# include <string.h>
# include <stdlib.h>
# include <stdio.h>
# include <errno.h>
#endif
#include "config.h"
#include "adns.h"
static const char *progname;
static void aargh(const char *msg) {
fprintf(stderr, "%s: %s: %s (%d)\n", progname, msg,
strerror(errno) ? strerror(errno) : "Unknown error", errno);
exit(1);
}
int main(int argc, char *argv[]) {
adns_state adns;
adns_query query;
adns_answer *answer;
progname= strrchr(*argv, '/');
if (progname)
progname++;
else
progname= *argv;
if (argc != 2) {
fprintf(stderr, "usage: %s <domain>\n", progname);
exit(1);
}
errno= adns_init(&adns, adns_if_debug, 0);
if (errno) aargh("adns_init");
errno= adns_submit(adns, argv[1], adns_r_ptr,
adns_qf_quoteok_cname|adns_qf_cname_loose,
NULL, &query);
if (errno) aargh("adns_submit");
errno= adns_wait(adns, &query, &answer, NULL);
if (errno) aargh("adns_init");
printf("%s\n", answer->status == adns_s_ok ? *answer->rrs.str : "dunno");
adns_finish(adns);
return 0;
}