mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-10-19 02:29:40 +00:00
Code Issues Releases Activity

Build bind-4.9.4-P1 nslookup

Browse Source
This commit is contained in:
Peter Wemm 1996-08-29 21:40:09 +00:00
parent 0be1da2627
commit bee5504dbe
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=17908
13 changed files with 14 additions and 5629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
usr.sbin/nslookup/Makefile
View File

@ -1,14 +1,22 @@
# @(#)Makefile 8.1 (Berkeley) 6/6/93
# $Id$
.include "${.CURDIR}/../named/Makefile.inc"
.PATH: ${BIND_DIR}/tools/nslookup
.PATH: ${BIND_DIR}/man
PROG= nslookup
SRCS= main.c commands.l getinfo.c debug.c send.c skip.c list.c subr.c
SRCS= main.c getinfo.c debug.c send.c skip.c list.c subr.c commands.c
MAN8= nslookup.8
DPADD+= ${LIBL}
LDADD+= -ll
CLEANFILES+=lex.yy.o
LDADD= -ll
DPADD= ${LIBL}
CLEANFILES+= commands.c lex.yy.c lex.yy.o
beforeinstall:
${INSTALL} -c -o ${BINOWN} -g ${BINGRP} -m 444 \
${.CURDIR}/nslookup.help ${DESTDIR}/usr/share/misc
${BIND_DIR}/tools/nslookup/nslookup.help \
${DESTDIR}/usr/share/misc/nslookup.help
.include <bsd.prog.mk>

219
usr.sbin/nslookup/commands.l
View File

@ -1,219 +0,0 @@
%{
/*
* ++Copyright++ 1985
* -
* Copyright (c) 1985
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)commands.l 5.13 (Berkeley) 7/24/90";
#endif /* not lint */
/*
*******************************************************************************
*
* commands.l
*
* Andrew Cherenson CS298-26 Fall 1985
*
* Lex input file for the nslookup program command interpreter.
* When a sequence is recognized, the associated action
* routine is called. The action routine may need to
* parse the string for additional information.
*
* Recognized commands: (identifiers are shown in uppercase)
*
* server NAME - set default server to NAME, using default server
* lserver NAME - set default server to NAME, using initial server
* finger [NAME] - finger the optional NAME
* exit - exit the program
* root - set default server to the root
* ls NAME - list the domain NAME
* view FILE - sorts and view the file with more
* set OPTION - set an option
* help - print help information
* ? - print help information
* NAME - print info about the host/domain NAME
* using default server.
* NAME1 NAME2 - as above, but use NAME2 as server
*
*
* yylex Results:
* 0 upon end-of-file.
* 1 after each command.
*
*******************************************************************************
*/
#include "res.h"
extern char rootServerName[];
extern void PrintHelp();
%}
WS [ \t]
FLET [A-Za-z0-9.*\\]
LET [A-Za-z0-9.*]
NAME [A-Za-z0-9.*=_/-]
%%
^{WS}*server{WS}+{LET}{NAME}*{WS}*$ {
/*
* 0 == use current server to find
* the new one.
* 1 == use original server to find
* the new one.
*/
SetDefaultServer(yytext, 0);
return(1);
}
^{WS}*lserver{WS}+{LET}{NAME}*{WS}*$ {
SetDefaultServer(yytext, 1);
return(1);
}
^{WS}*exit{WS}*$ {
return(0);
}
^{WS}*root{WS}*$ {
SetDefaultServer(rootServerName, 1);
return(1);
}
^{WS}*finger({WS}+{LET}{NAME}*)?{WS}+>>?{WS}*{NAME}+{WS}*$ {
/*
* 2nd arg.
* 0 == output to stdout
* 1 == output to file
*/
Finger(yytext, 1);
return(1);
}
^{WS}*finger({WS}+{LET}{NAME}*)?{WS}*$ {
Finger(yytext, 0);
return(1);
}
^{WS}*view{WS}+{NAME}+{WS}*$ {
ViewList(yytext);
return(1);
}
^{WS}*ls{WS}+(("-a"|"-d"|"-h"|"-m"|"-s"){WS}+)?{LET}{NAME}*{WS}+>>?{WS}+{NAME}+{WS}*$ {
/*
* 2nd arg.
* 0 == output to stdout
* 1 == output to file
*/
ListHosts(yytext, 1);
return(1);
}
^{WS}*ls{WS}+(("-a"|"-d"|"-h"|"-m"|"-s"){WS}+)?{LET}{NAME}*{WS}*$ {
ListHosts(yytext, 0);
return(1);
}
^{WS}*ls{WS}+-t{WS}+({LET}{NAME}*{WS}+)?{LET}{NAME}*{WS}+>>?{WS}+{NAME}+{WS}*$ {
/*
* 2nd arg.
* 0 == output to stdout
* 1 == output to file
*/
ListHostsByType(yytext, 1);
return(1);
}
^{WS}*ls{WS}+-t{WS}+({LET}{NAME}*{WS}+)?{LET}{NAME}*{WS}*$ {
ListHostsByType(yytext, 0);
return(1);
}
^{WS}*set{WS}+{NAME}+{WS}*$ {
SetOption(yytext);
return(1);
}
^{WS}*help{WS}*$ {
PrintHelp();
return(1);
}
^{WS}*"?"{WS}*$ {
extern void PrintHelp();
PrintHelp();
return(1);
}
^{WS}*{FLET}{NAME}*{WS}+>>?{WS}*{NAME}+{WS}*$ {
/*
* 0 == output to stdout
* 1 == output to file
*/
LookupHost(yytext, 1);
return(1);
}
^{WS}*{FLET}{NAME}*{WS}*$ {
LookupHost(yytext, 0);
return(1);
}
^{WS}*{FLET}{NAME}*{WS}+{LET}{NAME}*{WS}+>>?{WS}*{NAME}+{WS}*$ {
/*
* 0 == output to stdout
* 1 == output to file
*/
LookupHostWithServer(yytext, 1);
return(1);
}
^{WS}*{FLET}{NAME}*{WS}+{LET}{NAME}*{WS}*$ {
LookupHostWithServer(yytext, 0);
return(1);
}
^{WS}*\n {
return(1);
}
^.*\n {
printf("Unrecognized command: %s",
yytext);
return(1);
}
\n { ; }
%%

556
usr.sbin/nslookup/debug.c
View File

@ -1,556 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)debug.c 5.26 (Berkeley) 3/21/91";
static char rcsid[] = "$Id: debug.c,v 1.4 1995/08/20 22:32:46 peter Exp $";
#endif /* not lint */
/*
*******************************************************************************
*
* debug.c --
*
* Routines to print out packets received from a name server query.
*
* Modified version of 4.3BSD BIND res_debug.c 5.30 6/27/90
*
*******************************************************************************
*/
#include <sys/param.h>
#include <netinet/in.h>
#ifdef ISO
#include <netiso/iso.h>
#endif
#include <arpa/nameser.h>
#include <arpa/inet.h>
#include <resolv.h>
#include <netdb.h>
#include <stdio.h>
#include "res.h"
/*
* Imported from res_debug.c
*/
extern char *_res_resultcodes[];
extern char *_res_opcodes[];
/*
* Used to highlight the start of a record when printing it.
*/
#define INDENT " -> "
/*
* Print the contents of a query.
* This is intended to be primarily a debugging routine.
*/
Print_query(msg, eom, printHeader)
char *msg, *eom;
int printHeader;
{
Fprint_query(msg, eom, printHeader,stdout);
}
Fprint_query(msg, eom, printHeader,file)
u_char *msg, *eom;
int printHeader;
FILE *file;
{
register u_char *cp;
register HEADER *hp;
register int n;
short class;
short type;
/*
* Print header fields.
*/
hp = (HEADER *)msg;
cp = msg + HFIXEDSZ;
if (printHeader || (_res.options & RES_DEBUG2)) {
fprintf(file," HEADER:\n");
fprintf(file,"\topcode = %s", _res_opcodes[hp->opcode]);
fprintf(file,", id = %d", ntohs(hp->id));
fprintf(file,", rcode = %s\n", _res_resultcodes[hp->rcode]);
fprintf(file,"\theader flags: ");
if (hp->qr) {
fprintf(file," response");
} else {
fprintf(file," query");
}
if (hp->aa)
fprintf(file,", auth. answer");
if (hp->tc)
fprintf(file,", truncation");
if (hp->rd)
fprintf(file,", want recursion");
if (hp->ra)
fprintf(file,", recursion avail.");
fprintf(file,"\n\tquestions = %d", ntohs(hp->qdcount));
fprintf(file,", answers = %d", ntohs(hp->ancount));
fprintf(file,", authority records = %d", ntohs(hp->nscount));
fprintf(file,", additional = %d\n\n", ntohs(hp->arcount));
}
/*
* Print question records.
*/
if (n = ntohs(hp->qdcount)) {
fprintf(file," QUESTIONS:\n");
while (--n >= 0) {
fprintf(file,"\t");
cp = Print_cdname(cp, msg, eom, file);
if (cp == NULL)
return;
type = _getshort((u_char*)cp);
cp += INT16SZ;
class = _getshort((u_char*)cp);
cp += INT16SZ;
fprintf(file,", type = %s", p_type(type));
fprintf(file,", class = %s\n", p_class(class));
}
}
/*
* Print authoritative answer records
*/
if (n = ntohs(hp->ancount)) {
fprintf(file," ANSWERS:\n");
while (--n >= 0) {
fprintf(file, INDENT);
cp = Print_rr(cp, msg, eom, file);
if (cp == NULL)
return;
}
}
/*
* print name server records
*/
if (n = ntohs(hp->nscount)) {
fprintf(file," AUTHORITY RECORDS:\n");
while (--n >= 0) {
fprintf(file, INDENT);
cp = Print_rr(cp, msg, eom, file);
if (cp == NULL)
return;
}
}
/*
* print additional records
*/
if (n = ntohs(hp->arcount)) {
fprintf(file," ADDITIONAL RECORDS:\n");
while (--n >= 0) {
fprintf(file, INDENT);
cp = Print_rr(cp, msg, eom, file);
if (cp == NULL)
return;
}
}
fprintf(file,"\n------------\n");
}
u_char *
Print_cdname_sub(cp, msg, eom, file, format)
u_char *cp, *msg, *eom;
FILE *file;
int format;
{
int n;
char name[MAXDNAME];
n = dn_expand(msg, eom, cp, name, sizeof name);
if (n < 0)
return (NULL);
if (name[0] == '\0') {
(void) strcpy(name, "(root)");
}
if (format) {
fprintf(file, "%-30s", name);
} else {
fputs(name, file);
}
return (cp + n);
}
u_char *
Print_cdname(cp, msg, eom, file)
u_char *cp, *msg, *eom;
FILE *file;
{
return (Print_cdname_sub(cp, msg, eom, file, 0));
}
u_char *
Print_cdname2(cp, msg, eom, file)
u_char *cp, *msg, *eom;
FILE *file;
{
return (Print_cdname_sub(cp, msg, eom, file, 1));
}
/*
* Print resource record fields in human readable form.
*/
u_char *
Print_rr(cp, msg, eom, file)
u_char *cp, *msg, *eom;
FILE *file;
{
int type, class, dlen, n, c;
u_int32_t rrttl, ttl;
struct in_addr inaddr;
#ifdef ISO
struct iso_addr isoa;
#endif
u_char *cp1, *cp2;
int debug;
if ((cp = Print_cdname(cp, msg, eom, file)) == NULL) {
fprintf(file, "(name truncated?)\n");
return (NULL); /* compression error */
}
type = _getshort((u_char*)cp);
cp += INT16SZ;
class = _getshort((u_char*)cp);
cp += INT16SZ;
rrttl = _getlong((u_char*)cp);
cp += INT32SZ;
dlen = _getshort((u_char*)cp);
cp += INT16SZ;
debug = _res.options & (RES_DEBUG|RES_DEBUG2);
if (debug) {
if (_res.options & RES_DEBUG2) {
fprintf(file,"\n\ttype = %s, class = %s, dlen = %d",
p_type(type), p_class(class), dlen);
}
if (type == T_SOA) {
fprintf(file,"\n\tttl = %lu (%s)", rrttl, p_time(rrttl));
}
(void) putc('\n', file);
}
cp1 = cp;
/*
* Print type specific data, if appropriate
*/
switch (type) {
case T_A:
switch (class) {
case C_IN:
case C_HS:
bcopy(cp, (char *)&inaddr, INADDRSZ);
if (dlen == 4) {
fprintf(file,"\tinternet address = %s\n",
inet_ntoa(inaddr));
cp += dlen;
} else if (dlen == 7) {
fprintf(file,"\tinternet address = %s",
inet_ntoa(inaddr));
fprintf(file,", protocol = %d", cp[4]);
fprintf(file,", port = %d\n",
(cp[5] << 8) + cp[6]);
cp += dlen;
}
break;
default:
fprintf(file,"\taddress, class = %d, len = %d\n",
class, dlen);
cp += dlen;
}
break;
case T_CNAME:
fprintf(file,"\tcanonical name = ");
goto doname;
case T_MG:
fprintf(file,"\tmail group member = ");
goto doname;
case T_MB:
fprintf(file,"\tmail box = ");
goto doname;
case T_MR:
fprintf(file,"\tmailbox rename = ");
goto doname;
case T_MX:
fprintf(file,"\tpreference = %u",_getshort((u_char*)cp));
cp += INT16SZ;
fprintf(file,", mail exchanger = ");
goto doname;
case T_PX:
fprintf(file,"\tpreference = %u",_getshort((u_char*)cp));
cp += INT16SZ;
fprintf(file,", RFC 822 = ");
cp = Print_cdname(cp, msg, eom, file);
fprintf(file,"\nX.400 = ");
cp = Print_cdname(cp, msg, eom, file);
(void) putc('\n', file);
break;
case T_RT:
fprintf(file,"\tpreference = %u",_getshort((u_char*)cp));
cp += INT16SZ;
fprintf(file,", router = ");
goto doname;
case T_AFSDB:
fprintf(file,"\tsubtype = %d",_getshort((u_char*)cp));
cp += INT16SZ;
fprintf(file,", DCE/AFS server = ");
goto doname;
case T_NS:
fprintf(file,"\tnameserver = ");
goto doname;
case T_PTR:
fprintf(file,"\tname = ");
doname:
cp = Print_cdname(cp, msg, eom, file);
(void) putc('\n', file);
break;
case T_HINFO:
cp2 = cp + dlen;
if (n = *cp++) {
fprintf(file,"\tCPU = %.*s", n, cp);
cp += n;
}
if ((cp < cp2) && (n = *cp++)) {
fprintf(file,"\tOS = %.*s\n", n, cp);
cp += n;
} else fprintf(file, "\n*** Warning *** OS-type missing\n");
break;
case T_ISDN:
cp2 = cp + dlen;
if (n = *cp++) {
fprintf(file,"\tISDN = \"%.*s", n, cp);
cp += n;
}
if ((cp < cp2) && (n = *cp++)) {
fprintf(file,"-%.*s\"\n", n, cp);
cp += n;
} else fprintf(file,"\"\n");
break;
case T_SOA:
if (!debug)
(void) putc('\n', file);
fprintf(file,"\torigin = ");
cp = Print_cdname(cp, msg, eom, file);
fprintf(file,"\n\tmail addr = ");
cp = Print_cdname(cp, msg, eom, file);
fprintf(file,"\n\tserial = %lu", _getlong((u_char*)cp));
cp += INT32SZ;
ttl = _getlong((u_char*)cp);
fprintf(file,"\n\trefresh = %lu (%s)", ttl, p_time(ttl));
cp += INT32SZ;
ttl = _getlong((u_char*)cp);
fprintf(file,"\n\tretry = %lu (%s)", ttl, p_time(ttl));
cp += INT32SZ;
ttl = _getlong((u_char*)cp);
fprintf(file,"\n\texpire = %lu (%s)", ttl, p_time(ttl));
cp += INT32SZ;
ttl = _getlong((u_char*)cp);
fprintf(file,
"\n\tminimum ttl = %lu (%s)\n", ttl, p_time(ttl));
cp += INT32SZ;
break;
case T_MINFO:
if (!debug)
(void) putc('\n', file);
fprintf(file,"\trequests = ");
cp = Print_cdname(cp, msg, eom, file);
fprintf(file,"\n\terrors = ");
cp = Print_cdname(cp, msg, eom, file);
(void) putc('\n', file);
break;
case T_RP:
if (!debug)
(void) putc('\n', file);
fprintf(file,"\tmailbox = ");
cp = Print_cdname(cp, msg, eom, file);
fprintf(file,"\n\ttext = ");
cp = Print_cdname(cp, msg, eom, file);
(void) putc('\n', file);
break;
case T_TXT:
(void) fputs("\ttext = \"", file);
cp2 = cp1 + dlen;
while (cp < cp2) {
if (n = (unsigned char) *cp++) {
for (c = n; c > 0 && cp < cp2; c--)
if ((*cp == '\n') || (*cp == '"')) {
(void) putc('\\', file);
(void) putc(*cp++, file);
} else
(void) putc(*cp++, file);
}
}
(void) fputs("\"\n", file);
break;
case T_X25:
(void) fputs("\tX25 = \"", file);
cp2 = cp1 + dlen;
while (cp < cp2) {
if (n = (unsigned char) *cp++) {
for (c = n; c > 0 && cp < cp2; c--)
if (*cp == '\n') {
(void) putc('\\', file);
(void) putc(*cp++, file);
} else
(void) putc(*cp++, file);
}
}
(void) fputs("\"\n", file);
break;
#ifdef ISO
case T_NSAP:
isoa.isoa_len = dlen;
if (isoa.isoa_len > sizeof(isoa.isoa_genaddr))
isoa.isoa_len = sizeof(isoa.isoa_genaddr);
bcopy(cp, isoa.isoa_genaddr, isoa.isoa_len);
fprintf(file, "\tnsap = %s\n", iso_ntoa(&isoa));
cp += dlen;
break;
#endif
case T_UINFO:
fprintf(file,"\tuser info = %s\n", cp);
cp += dlen;
break;
case T_UID:
case T_GID:
if (dlen == 4) {
fprintf(file,"\t%cid = %u\n",type == T_UID ? 'u' : 'g',
_getlong((u_char*)cp));
cp += INT32SZ;
} else {
fprintf(file,"\t%cid of length %d?\n",
type == T_UID ? 'u' : 'g', dlen);
cp += dlen;
}
break;
case T_WKS: {
struct protoent *protoPtr;
if (dlen < INT32SZ + 1)
break;
if (!debug)
(void) putc('\n', file);
bcopy(cp, (char *)&inaddr, INADDRSZ);
cp += INT32SZ;
if ((protoPtr = getprotobynumber(*cp)) != NULL) {
fprintf(file,"\tinet address = %s, protocol = %s\n\t",
inet_ntoa(inaddr), protoPtr->p_name);
} else {
fprintf(file,"\tinet address = %s, protocol = %d\n\t",
inet_ntoa(inaddr), *cp);
}
cp++;
n = 0;
while (cp < cp1 + dlen) {
c = *cp++;
do {
struct servent *s;
if (c & 0200) {
s = getservbyport((int)htons(n),
protoPtr ? protoPtr->p_name : NULL);
if (s != NULL) {
fprintf(file," %s", s->s_name);
} else {
fprintf(file," #%d", n);
}
}
c <<= 1;
} while (++n & 07);
}
putc('\n',file);
}
break;
case T_NULL:
fprintf(file, "\tNULL (dlen %d)\n", dlen);
cp += dlen;
break;
default:
fprintf(file,"\t??? unknown type %d ???\n", type);
cp += dlen;
}
if (_res.options & RES_DEBUG && type != T_SOA) {
fprintf(file,"\tttl = %lu (%s)\n", rrttl, p_time(rrttl));
}
if (cp != cp1 + dlen) {
fprintf(file,
"\n*** Error: record size incorrect (%d != %d)\n\n",
cp - cp1, dlen);
cp = NULL;
}
return (cp);
}

842
usr.sbin/nslookup/getinfo.c
View File

@ -1,842 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)getinfo.c 5.26 (Berkeley) 3/21/91";
static char rcsid[] = "$Id: getinfo.c,v 1.3 1995/05/30 03:49:14 rgrimes Exp $";
#endif /* not lint */
/*
******************************************************************************
*
* getinfo.c --
*
* Routines to create requests to name servers
* and interpret the answers.
*
* Adapted from 4.3BSD BIND gethostnamadr.c
*
******************************************************************************
*/
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <arpa/inet.h>
#include <resolv.h>
#include <stdio.h>
#include <ctype.h>
#include "res.h"
extern char *_res_resultcodes[];
extern char *res_skip();
#define MAXALIASES 35
#define MAXADDRS 35
#define MAXDOMAINS 35
#define MAXSERVERS 10
static char *addr_list[MAXADDRS + 1];
static char *host_aliases[MAXALIASES];
static int host_aliases_len[MAXALIASES];
static u_char hostbuf[BUFSIZ+1];
typedef struct {
char *name;
char *domain[MAXDOMAINS];
int numDomains;
char *address[MAXADDRS];
int numAddresses;
} ServerTable;
ServerTable server[MAXSERVERS];
typedef union {
HEADER qb1;
u_char qb2[PACKETSZ*2];
} querybuf;
typedef union {
int32_t al;
char ac;
} align;
#define GetShort(cp) _getshort(cp); cp += INT16SZ;
/*
******************************************************************************
*
* GetAnswer --
*
* Interprets an answer packet and retrieves the following
* information:
*
* Results:
* SUCCESS the info was retrieved.
* NO_INFO the packet did not contain an answer.
* NONAUTH non-authoritative information was found.
* ERROR the answer was malformed.
* Other errors returned in the packet header.
*
******************************************************************************
*/
static int
GetAnswer(nsAddrPtr, queryType, msg, msglen, iquery, hostPtr, isServer)
struct in_addr *nsAddrPtr;
char *msg;
int queryType;
int msglen;
Boolean iquery;
register HostInfo *hostPtr;
Boolean isServer;
{
register HEADER *headerPtr;
register u_char *cp;
querybuf answer;
char **aliasPtr;
u_char *eom, *bp;
char **addrPtr;
char *namePtr;
char *dnamePtr;
int type, class;
int qdcount, ancount, arcount, nscount, buflen;
int origClass;
int numAliases = 0;
int numAddresses = 0;
int n, i, j;
int len;
int dlen;
int status;
int numServers;
Boolean haveAnswer;
Boolean printedAnswers = FALSE;
/*
* If the hostPtr was used before, free up the calloc'd areas.
*/
FreeHostInfoPtr(hostPtr);
status = SendRequest(nsAddrPtr, msg, msglen, (char *) &answer,
sizeof(answer), &n);
if (status != SUCCESS) {
if (_res.options & RES_DEBUG2)
printf("SendRequest failed\n");
return (status);
}
eom = (u_char *) &answer + n;
headerPtr = (HEADER *) &answer;
if (headerPtr->rcode != NOERROR) {
return (headerPtr->rcode);
}
qdcount = ntohs(headerPtr->qdcount);
ancount = ntohs(headerPtr->ancount);
arcount = ntohs(headerPtr->arcount);
nscount = ntohs(headerPtr->nscount);
/*
* If there are no answer, n.s. or additional records
* then return with an error.
*/
if (ancount == 0 && nscount == 0 && arcount == 0) {
return (NO_INFO);
}
bp = hostbuf;
buflen = sizeof(hostbuf);
cp = (u_char *) &answer + HFIXEDSZ;
/* Skip over question section. */
while (qdcount-- > 0) {
cp += dn_skipname(cp, eom) + QFIXEDSZ;
}
aliasPtr = host_aliases;
addrPtr = addr_list;
haveAnswer = FALSE;
/*
* Scan through the answer resource records.
* Answers for address query types are saved.
* Other query type answers are just printed.
*/
if (ancount != 0) {
if (!isServer && !headerPtr->aa) {
printf("Non-authoritative answer:\n");
}
if (queryType != T_A && !(iquery && queryType == T_PTR)) {
while (--ancount >= 0 && cp < eom) {
if ((cp = (u_char *)Print_rr(cp,
(char *)&answer, eom, stdout)) == NULL) {
return(ERROR);
}
}
printedAnswers = TRUE;
} else {
while (--ancount >= 0 && cp < eom) {
n = dn_expand(answer.qb2, eom, cp, (char *)bp, buflen);
if (n < 0) {
return(ERROR);
}
cp += n;
type = GetShort(cp);
class = GetShort(cp);
cp += INT32SZ; /* skip TTL */
dlen = GetShort(cp);
if (type == T_CNAME) {
/*
* Found an alias.
*/
cp += dlen;
if (aliasPtr >= &host_aliases[MAXALIASES-1]) {
continue;
}
*aliasPtr++ = (char *)bp;
n = strlen((char *)bp) + 1;
host_aliases_len[numAliases] = n;
numAliases++;
bp += n;
buflen -= n;
continue;
} else if (type == T_PTR) {
/*
* Found a "pointer" to the real name.
*/
n = dn_expand(answer.qb2, eom, cp, (char *)bp, buflen);
if (n < 0) {
cp += n;
continue;
}
cp += n;
len = strlen((char *)bp) + 1;
hostPtr->name = Calloc(1, len);
bcopy(bp, hostPtr->name, len);
haveAnswer = TRUE;
break;
} else if (type != T_A) {
cp += dlen;
continue;
}
if (haveAnswer) {
/*
* If we've already got 1 address, we aren't interested
* in addresses with a different length or class.
*/
if (dlen != hostPtr->addrLen) {
cp += dlen;
continue;
}
if (class != origClass) {
cp += dlen;
continue;
}
} else {
/*
* First address: record its length and class so we
* only save additonal ones with the same attributes.
*/
hostPtr->addrLen = dlen;
origClass = class;
hostPtr->addrType = (class == C_IN) ? AF_INET : AF_UNSPEC;
len = strlen((char *)bp) + 1;
hostPtr->name = Calloc(1, len);
bcopy(bp, hostPtr->name, len);
}
bp += (((u_int32_t)bp) % sizeof(align));
if (bp + dlen >= &hostbuf[sizeof(hostbuf)]) {
if (_res.options & RES_DEBUG) {
printf("Size (%d) too big\n", dlen);
}
break;
}
bcopy(cp, *addrPtr++ = (char *)bp, dlen);
bp +=dlen;
cp += dlen;
numAddresses++;
haveAnswer = TRUE;
}
}
}
if ((queryType == T_A || queryType == T_PTR) && haveAnswer) {
/*
* Go through the alias and address lists and return them
* in the hostPtr variable.
*/
if (numAliases > 0) {
hostPtr->aliases =
(char **) Calloc(1 + numAliases, sizeof(char *));
for (i = 0; i < numAliases; i++) {
hostPtr->aliases[i] = Calloc(1, host_aliases_len[i]);
bcopy(host_aliases[i],
hostPtr->aliases[i],
host_aliases_len[i]);
}
hostPtr->aliases[i] = NULL;
}
if (numAddresses > 0) {
hostPtr->addrList =
(char **)Calloc(1+numAddresses, sizeof(char *));
for (i = 0; i < numAddresses; i++) {
hostPtr->addrList[i] = Calloc(1, hostPtr->addrLen);
bcopy(addr_list[i], hostPtr->addrList[i], hostPtr->addrLen);
}
hostPtr->addrList[i] = NULL;
}
#ifdef verbose
if (headerPtr->aa || nscount == 0) {
hostPtr->servers = NULL;
return (SUCCESS);
}
#else
hostPtr->servers = NULL;
return (SUCCESS);
#endif
}
/*
* At this point, for the T_A query type, only empty answers remain.
* For other query types, additional information might be found
* in the additional resource records part.
*/
if (!headerPtr->aa && (queryType != T_A) && (nscount > 0 || arcount > 0)) {
if (printedAnswers) {
putchar('\n');
}
printf("Authoritative answers can be found from:\n");
}
cp = (u_char *)res_skip((char *) &answer, 2, eom);
numServers = 0;
if (queryType != T_A) {
/*
* If we don't need to save the record, just print it.
*/
while (--nscount >= 0 && cp < eom) {
if ((cp = (u_char *)Print_rr(cp,
(char *) &answer, eom, stdout)) == NULL) {
return(ERROR);
}
}
} else {
while (--nscount >= 0 && cp < eom) {
/*
* Go through the NS records and retrieve the names of hosts
* that serve the requested domain.
*/
n = dn_expand(answer.qb2, eom, cp, (char *)bp, buflen);
if (n < 0) {
return(ERROR);
}
cp += n;
len = strlen((char *)bp) + 1;
dnamePtr = Calloc(1, len); /* domain name */
bcopy(bp, dnamePtr, len);
type = GetShort(cp);
class = GetShort(cp);
cp += INT32SZ; /* skip TTL */
dlen = GetShort(cp);
if (type != T_NS) {
cp += dlen;
} else {
Boolean found;
n = dn_expand(answer.qb2, eom, cp, (char *)bp, buflen);
if (n < 0) {
return(ERROR);
}
cp += n;
len = strlen((char *)bp) + 1;
namePtr = Calloc(1, len); /* server host name */
bcopy(bp, namePtr, len);
/*
* Store the information keyed by the server host name.
*/
found = FALSE;
for (j = 0; j < numServers; j++) {
if (strcmp(namePtr, server[j].name) == 0) {
found = TRUE;
free(namePtr);
break;
}
}
if (found) {
server[j].numDomains++;
if (server[j].numDomains <= MAXDOMAINS) {
server[j].domain[server[j].numDomains-1] = dnamePtr;
}
} else {
if (numServers >= MAXSERVERS) {
break;
}
server[numServers].name = namePtr;
server[numServers].domain[0] = dnamePtr;
server[numServers].numDomains = 1;
server[numServers].numAddresses = 0;
numServers++;
}
}
}
}
/*
* Additional resource records contain addresses of servers.
*/
cp = (u_char *)res_skip((char *) &answer, 3, eom);
if (queryType != T_A) {
/*
* If we don't need to save the record, just print it.
*/
while (--arcount >= 0 && cp < eom) {
if ((cp = (u_char *)Print_rr(cp,
(char *) &answer, eom, stdout)) == NULL) {
return(ERROR);
}
}
} else {
while (--arcount >= 0 && cp < eom) {
n = dn_expand(answer.qb2, eom, cp, (char *)bp, buflen);
if (n < 0) {
break;
}
cp += n;
type = GetShort(cp);
class = GetShort(cp);
cp += INT32SZ; /* skip TTL */
dlen = GetShort(cp);
if (type != T_A) {
cp += dlen;
continue;
} else {
for (j = 0; j < numServers; j++) {
if (strcmp((char *)bp, server[j].name) == 0) {
server[j].numAddresses++;
if (server[j].numAddresses <= MAXADDRS) {
server[j].address[server[j].numAddresses-1] =
Calloc(1,dlen);
bcopy(cp,
server[j].address[server[j].numAddresses-1],dlen);
break;
}
}
}
cp += dlen;
}
}
}
/*
* If we are returning name server info, transfer it to the hostPtr.
*/
if (numServers > 0) {
hostPtr->servers = (ServerInfo **)
Calloc(numServers+1, sizeof(ServerInfo *));
for (i = 0; i < numServers; i++) {
hostPtr->servers[i] = (ServerInfo *) Calloc(1, sizeof(ServerInfo));
hostPtr->servers[i]->name = server[i].name;
hostPtr->servers[i]->domains = (char **)
Calloc(server[i].numDomains+1,sizeof(char *));
for (j = 0; j < server[i].numDomains; j++) {
hostPtr->servers[i]->domains[j] = server[i].domain[j];
}
hostPtr->servers[i]->domains[j] = NULL;
hostPtr->servers[i]->addrList = (char **)
Calloc(server[i].numAddresses+1,sizeof(char *));
for (j = 0; j < server[i].numAddresses; j++) {
hostPtr->servers[i]->addrList[j] = server[i].address[j];
}
hostPtr->servers[i]->addrList[j] = NULL;
}
hostPtr->servers[i] = NULL;
}
switch (queryType) {
case T_A:
return NONAUTH;
case T_PTR:
if (iquery)
return NO_INFO;
/* fall through */
default:
return SUCCESS;
}
}
/*
*******************************************************************************
*
* GetHostInfo --
*
* Retrieves host name, address and alias information
* for a domain.
*
* Algorithm from res_search().
*
* Results:
* ERROR - res_mkquery failed.
* + return values from GetAnswer()
*
*******************************************************************************
*/
int
GetHostInfoByName(nsAddrPtr, queryClass, queryType, name, hostPtr, isServer)
struct in_addr *nsAddrPtr;
int queryClass;
int queryType;
char *name;
HostInfo *hostPtr;
Boolean isServer;
{
int n;
register int result;
register char *cp, **domain;
Boolean got_nodata = FALSE;
struct in_addr ina;
Boolean tried_as_is = FALSE;
/* Catch explicit addresses */
if ((queryType == T_A) && IsAddr(name, &ina)) {
hostPtr->name = Calloc(strlen(name)+3, 1);
(void)sprintf(hostPtr->name,"[%s]",name);
hostPtr->aliases = NULL;
hostPtr->servers = NULL;
hostPtr->addrType = AF_INET;
hostPtr->addrLen = INADDRSZ;
hostPtr->addrList = (char **)Calloc(2, sizeof(char *));
hostPtr->addrList[0] = Calloc(INT32SZ, sizeof(char));
bcopy((char *)&ina, hostPtr->addrList[0], INADDRSZ);
hostPtr->addrList[1] = NULL;
return(SUCCESS);
}
result = NXDOMAIN;
for (cp = name, n = 0; *cp; cp++)
if (*cp == '.')
n++;
if (n == 0 && (cp = hostalias(name))) {
printf("Aliased to \"%s\"\n\n", cp);
return (GetHostDomain(nsAddrPtr, queryClass, queryType,
cp, (char *)NULL, hostPtr, isServer));
}
/*
* If there are dots in the name already, let's just give it a try
* 'as is'. The threshold can be set with the "ndots" option.
*/
if (n >= (int)_res.ndots) {
result = GetHostDomain(nsAddrPtr, queryClass, queryType,
name, (char *)NULL, hostPtr, isServer);
if (result == SUCCESS)
return (result);
if (result == NO_INFO)
got_nodata++;
tried_as_is++;
}
/*
* We do at least one level of search if
* - there is no dot and RES_DEFNAME is set, or
* - there is at least one dot, there is no trailing dot,
* and RES_DNSRCH is set.
*/
if ((n == 0 && _res.options & RES_DEFNAMES) ||
(n != 0 && *--cp != '.' && _res.options & RES_DNSRCH))
for (domain = _res.dnsrch; *domain; domain++) {
result = GetHostDomain(nsAddrPtr, queryClass, queryType,
name, *domain, hostPtr, isServer);
/*
* If no server present, give up.
* If name isn't found in this domain,
* keep trying higher domains in the search list
* (if that's enabled).
* On a NO_INFO error, keep trying, otherwise
* a wildcard entry of another type could keep us
* from finding this entry higher in the domain.
* If we get some other error (negative answer or
* server failure), then stop searching up,
* but try the input name below in case it's fully-qualified.
*/
if (result == SUCCESS || result == NO_RESPONSE)
return result;
if (result == NO_INFO)
got_nodata++;
if ((result != NXDOMAIN && result != NO_INFO) ||
(_res.options & RES_DNSRCH) == 0)
break;
}
/* if we have not already tried the name "as is", do that now.
* note that we do this regardless of how many dots were in the
* name or whether it ends with a dot.
*/
if (!tried_as_is &&
(result = GetHostDomain(nsAddrPtr, queryClass, queryType,
name, (char *)NULL, hostPtr, isServer)
) == SUCCESS)
return (result);
if (got_nodata)
result = NO_INFO;
return (result);
}
/*
* Perform a query on the concatenation of name and domain,
* removing a trailing dot from name if domain is NULL.
*/
GetHostDomain(nsAddrPtr, queryClass, queryType, name, domain, hostPtr, isServer)
struct in_addr *nsAddrPtr;
int queryClass;
int queryType;
char *name, *domain;
HostInfo *hostPtr;
Boolean isServer;
{
querybuf buf;
char nbuf[2*MAXDNAME+2];
char *longname = nbuf;
int n;
if (domain == NULL) {
/*
* Check for trailing '.';
* copy without '.' if present.
*/
n = strlen(name) - 1;
if (name[n] == '.' && n < sizeof(nbuf) - 1) {
bcopy(name, nbuf, n);
nbuf[n] = '\0';
} else
longname = name;
} else {
(void)sprintf(nbuf, "%.*s.%.*s",
MAXDNAME, name, MAXDNAME, domain);
longname = nbuf;
}
n = res_mkquery(QUERY, longname, queryClass, queryType,
NULL, 0, 0, buf.qb2, sizeof(buf));
if (n < 0) {
if (_res.options & RES_DEBUG) {
printf("Res_mkquery failed\n");
}
return (ERROR);
}
n = GetAnswer(nsAddrPtr, queryType, (char *)&buf, n, 0, hostPtr, isServer);
/*
* GetAnswer didn't find a name, so set it to the specified one.
*/
if (n == NONAUTH) {
if (hostPtr->name == NULL) {
int len = strlen(longname) + 1;
hostPtr->name = Calloc(len, sizeof(char));
bcopy(longname, hostPtr->name, len);
}
}
return(n);
}
/*
*******************************************************************************
*
* GetHostInfoByAddr --
*
* Performs a PTR lookup in in-addr.arpa to find the host name
* that corresponds to the given address.
*
* Results:
* ERROR - res_mkquery failed.
* + return values from GetAnswer()
*
*******************************************************************************
*/
int
GetHostInfoByAddr(nsAddrPtr, address, hostPtr)
struct in_addr *nsAddrPtr;
struct in_addr *address;
HostInfo *hostPtr;
{
int n;
querybuf buf;
char qbuf[MAXDNAME];
char *p = (char *) &address->s_addr;
(void)sprintf(qbuf, "%u.%u.%u.%u.in-addr.arpa",
((unsigned)p[3] & 0xff),
((unsigned)p[2] & 0xff),
((unsigned)p[1] & 0xff),
((unsigned)p[0] & 0xff));
n = res_mkquery(QUERY, qbuf, C_IN, T_PTR, NULL, 0, NULL,
buf.qb2, sizeof buf);
if (n < 0) {
if (_res.options & RES_DEBUG) {
printf("res_mkquery() failed\n");
}
return (ERROR);
}
n = GetAnswer(nsAddrPtr, T_PTR, (char *) &buf, n, 1, hostPtr, 1);
if (n == SUCCESS) {
hostPtr->addrType = AF_INET;
hostPtr->addrLen = 4;
hostPtr->addrList = (char **)Calloc(2, sizeof(char *));
hostPtr->addrList[0] = Calloc(INT32SZ, sizeof(char));
bcopy((char *)p, hostPtr->addrList[0], INADDRSZ);
hostPtr->addrList[1] = NULL;
}
return n;
}
/*
*******************************************************************************
*
* FreeHostInfoPtr --
*
* Deallocates all the calloc'd areas for a HostInfo variable.
*
*******************************************************************************
*/
void
FreeHostInfoPtr(hostPtr)
register HostInfo *hostPtr;
{
int i, j;
if (hostPtr->name != NULL) {
free(hostPtr->name);
hostPtr->name = NULL;
}
if (hostPtr->aliases != NULL) {
i = 0;
while (hostPtr->aliases[i] != NULL) {
free(hostPtr->aliases[i]);
i++;
}
free((char *)hostPtr->aliases);
hostPtr->aliases = NULL;
}
if (hostPtr->addrList != NULL) {
i = 0;
while (hostPtr->addrList[i] != NULL) {
free(hostPtr->addrList[i]);
i++;
}
free((char *)hostPtr->addrList);
hostPtr->addrList = NULL;
}
if (hostPtr->servers != NULL) {
i = 0;
while (hostPtr->servers[i] != NULL) {
if (hostPtr->servers[i]->name != NULL) {
free(hostPtr->servers[i]->name);
}
if (hostPtr->servers[i]->domains != NULL) {
j = 0;
while (hostPtr->servers[i]->domains[j] != NULL) {
free(hostPtr->servers[i]->domains[j]);
j++;
}
free((char *)hostPtr->servers[i]->domains);
}
if (hostPtr->servers[i]->addrList != NULL) {
j = 0;
while (hostPtr->servers[i]->addrList[j] != NULL) {
free(hostPtr->servers[i]->addrList[j]);
j++;
}
free((char *)hostPtr->servers[i]->addrList);
}
free((char *)hostPtr->servers[i]);
i++;
}
free((char *)hostPtr->servers);
hostPtr->servers = NULL;
}
}

1036
usr.sbin/nslookup/list.c
View File

File diff suppressed because it is too large Load Diff

1112
usr.sbin/nslookup/main.c
View File

File diff suppressed because it is too large Load Diff

387
usr.sbin/nslookup/nslookup.8
View File

@ -1,387 +0,0 @@
.\"
.\" ++Copyright++ 1985, 1989
.\" -
.\" Copyright (c) 1985, 1989
.\" The Regents of the University of California. All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\" notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\" notice, this list of conditions and the following disclaimer in the
.\" documentation and/or other materials provided with the distribution.
.\" 3. All advertising materials mentioning features or use of this software
.\" must display the following acknowledgement:
.\" This product includes software developed by the University of
.\" California, Berkeley and its contributors.
.\" 4. Neither the name of the University nor the names of its contributors
.\" may be used to endorse or promote products derived from this software
.\" without specific prior written permission.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\" -
.\" Portions Copyright (c) 1993 by Digital Equipment Corporation.
.\"
.\" Permission to use, copy, modify, and distribute this software for any
.\" purpose with or without fee is hereby granted, provided that the above
.\" copyright notice and this permission notice appear in all copies, and that
.\" the name of Digital Equipment Corporation not be used in advertising or
.\" publicity pertaining to distribution of the document or software without
.\" specific, written prior permission.
.\"
.\" THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
.\" WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
.\" OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
.\" CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
.\" DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
.\" PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
.\" ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
.\" SOFTWARE.
.\" -
.\" --Copyright--
.\"
.\" @(#)nslookup.8 5.3 (Berkeley) 6/24/90
.\"
.TH NSLOOKUP 8 "June 24, 1990"
.UC 6
.SH NAME
nslookup \- query Internet name servers interactively
.SH SYNOPSIS
.B nslookup
[
.I \-option ...
]
[
.I host-to-find
| \- [
.I server
]]
.SH DESCRIPTION
.I Nslookup
is a program to query Internet domain name servers.
Nslookup has two modes: interactive and non-interactive.
Interactive mode allows the user to query name servers for
information about various hosts and domains or to print a list of hosts
in a domain.
Non-interactive mode is used to print just the name and requested information
for a host or domain.
.sp 1
.SH ARGUMENTS
Interactive mode is entered in the following cases:
.IP a) 4
when no arguments are given (the default name server will be used),
.IP b) 4
when the first argument is a hyphen (\-) and the second argument
is the host name or Internet address of a name server.
.LP
Non-interactive mode is used when the name or Internet address
of the host to be looked up
is given as the first argument. The optional second argument specifies
the host name or address of a name server.
.LP
The options listed under the ``set'' command below can be specified in
the .nslookuprc file in the user's home directory if they are listed
one per line. Options can also be specified
on the command line if they precede the arguments and are prefixed with
a hyphen. For example, to change the default query type to host information,
and the initial timeout to 10 seconds, type:
.sp .5v
nslookup \-query=hinfo \-timeout=10
.sp .5v
.SH "INTERACTIVE COMMANDS"
Commands may be interrupted at any time by typing a control-C.
To exit, type a control-D (EOF) or type exit.
The command line length must be less than 256 characters.
To treat a built-in command as a host name,
precede it with an escape character (\e).
\fBN.B.\fP an unrecognized command will be interpreted as a host name.
.sp .5v
.IP "\fIhost\fP [\fIserver\fP]"
Look up information for \fIhost\fP using the current default server
or using \fIserver\fP if specified.
If \fIhost\fP is an Internet address and the query type is A or PTR, the
name of the host is returned.
If \fIhost\fP is a name and does not have a trailing period, the default
domain name is appended to the name. (This behavior depends on the state of the
\fBset\fP options \fBdomain\fP, \fBsrchlist\fP,
\fBdefname\fP, and \fBsearch\fP).
To look up a host not in the current domain, append a period to
the name.
.sp 1
.IP "\fBserver\fP \fIdomain\fP"
.ns
.IP "\fBlserver\fP \fIdomain\fP"
Change the default server to \fIdomain\fP.
\fBLserver\fP uses the initial server to look up
information about \fIdomain\fP while \fBserver\fP
uses the current default server.
If an authoritative answer can't be found, the names of servers
that might have the answer are returned.
.sp 1
.IP \fBroot\fP
Changes the default server to the server for the root of the domain name space.
Currently, the host ns.internic.net is used.
(This command is a synonym for \fBlserver ns.internic.net.\fP)
The name of the root server can be changed with the \fBset root\fP command.
.sp 1
.IP "\fBfinger\fP [\fIname\fP] [\fB>\fP \fIfilename\fP]"
.ns
.IP "\fBfinger\fP [\fIname\fP] [\fB>>\fP \fIfilename\fP]"
Connects with the finger server on the current host.
The current host is defined when a previous lookup for a host
was successful and returned address information (see the
\fBset querytype=A\fP command).
\fIName\fP is optional.
\fB>\fP and \fB>>\fP can be used to redirect output in the
usual manner.
.sp 1
.IP "\fBls\fR [\fIoption\fR] \fIdomain\fR [\fB>\fR \fIfilename\fR]"
.ns
.IP "\fBls\fR [\fIoption\fR] \fIdomain\fR [\fB>>\fR \fIfilename\fR]"
List the information available for \fIdomain\fP, optionally creating
or appending to \fIfilename\fP.
The default output contains host names and their Internet addresses.
.I Option
can be one of the following:
.RS
.IP "\fB\-t \fIquerytype\fP" 4
lists all records of the specified type (see \fIquerytype\fP below).
.IP \fB\-a\fP 4
lists aliases of hosts in the domain.
synonym for \fB\-t\ \ CNAME\fP.
.IP \fB\-d\fP 4
lists all records for the domain.
synonym for \fB\-t\ \ ANY\fP.
.IP \fB\-h\fP 4
lists CPU and operating system information for the domain.
synonym for \fB\-t\ \ HINFO\fP.
.IP \fB\-s\fP 4
lists well-known services of hosts in the domain.
synonym for \fB\-t\ \ WKS\fP.
.P
When output is directed to a file, hash marks are printed for every
50 records received from the server.
.RE
.sp 1
.IP "\fBview\fP \fIfilename\fP"
Sorts and lists the output of previous \fBls\fP command(s) with
\fImore\fP(1).
.sp 1
.ne 4
.IP "\fBhelp\fP"
.ns
.IP "\fB?\fP"
Prints a brief summary of commands.
.sp 1
.IP "\fBexit\fP"
Exits the program.
.sp 1
.IP "\fBset\fP \fIkeyword\fP[=\fIvalue\fP]"
This command is used to change state information that affects the lookups.
Valid keywords are:
.RS
.IP "\fBall\fP"
Prints the current values of the frequently-used options to \fBset\fP.
Information about the current default server and host is also printed.
.IP "\fBclass=\fIvalue\fR"
Change the query class to one of:
.RS
.IP IN 10
the Internet class.
.IP CHAOS 10
the Chaos class.
.IP HESIOD 10
the MIT Athena Hesiod class.
.IP ANY 10
wildcard (any of the above).
.P
The class specifies the protocol group of the information.
.br
(Default = IN, abbreviation = cl)
.RE
.IP "\fB[no]debug\fP"
Turn debugging mode on. A lot more information is printed about the
packet sent to the server and the resulting answer.
.br
(Default = nodebug, abbreviation = [no]deb)
.IP "\fB[no]d2\fP"
Turn exhaustive debugging mode on.
Essentially all fields of every packet are printed.
.br
(Default = nod2)
.IP "\fBdomain=\fIname\fR"
Change the default domain name to \fIname\fP.
The default domain name is appended to a lookup request depending on the
state of the \fBdefname\fP and \fBsearch\fP options.
The domain search list contains the parents of the default domain if it has
at least two components in its name.
For example, if the default domain
is CC.Berkeley.EDU, the search list is CC.Berkeley.EDU and Berkeley.EDU.
Use the \fBset srchlist\fP command to specify a different list.
Use the \fBset all\fP command to display the list.
.br
(Default = value from hostname, /etc/resolv.conf or LOCALDOMAIN,
abbreviation = do)
.IP "\fBsrchlist=\fIname1/name2/...\fR"
Change the default domain name to \fIname1\fP and the domain search list
to \fIname1\fP, \fIname2\fP, etc. A maximum of 6 names separated by slashes (/)
can be specified.
For example,
.sp .5v
set\ srchlist=lcs.MIT.EDU/ai.MIT.EDU/MIT.EDU
.sp .5v
sets the domain to lcs.MIT.EDU and the search list to the three names.
This command overrides the
default domain name and search list of the \fBset domain\fP command.
Use the \fBset all\fP command to display the list.
.br
(Default = value based on hostname, /etc/resolv.conf or LOCALDOMAIN,
abbreviation = srchl)
.IP "\fB[no]defname\fP"
If set, append the default domain name to a single-component lookup request
(i.e., one that does not contain a period).
.br
(Default = defname, abbreviation = [no]def)
.IP "\fB[no]search\fP"
If the lookup request contains at least one period but doesn't end
with a trailing period,
append the domain names in the domain search list
to the request until an answer is received.
.br
(Default = search, abbreviation = [no]sea)
.IP "\fBport=\fIvalue\fR"
Change the default TCP/UDP name server port to \fIvalue\fP.
.br
(Default = 53, abbreviation = po)
.IP "\fBquerytype=\fIvalue\fR"
.ns
.IP "\fBtype=\fIvalue\fR"
.ns
Change the type of information query to one of:
.RS
.IP A 10
the host's Internet address.
.IP CNAME 10
the canonical name for an alias.
.IP HINFO 10
the host CPU and operating system type.
.IP MINFO 10
the mailbox or mail list information.
.IP MX 10
the mail exchanger.
.IP NS 10
the name server for the named zone.
.IP PTR 10
the host name if the query is an Internet address,
otherwise the pointer to other information.
.IP SOA 10
the domain's ``start-of-authority'' information.
.IP TXT 10
the text information.
.IP UINFO 10
the user information.
.IP WKS 10
the supported well-known services.
.P
Other types (ANY, AXFR, MB, MD, MF, NULL) are described in the
RFC-1035 document.
.br
(Default = A, abbreviations = q, ty)
.RE
.IP "\fB[no]recurse\fP"
Tell the name server to query other servers if it does not have the
information.
.br
(Default = recurse, abbreviation = [no]rec)
.IP \fBretry=\fInumber\fR
Set the number of retries to \fInumber\fP.
When a reply to a request is not received within a certain
amount of time (changed with \fBset timeout\fP),
the timeout period is doubled and the request is resent.
The retry value controls how many times a request is resent before giving up.
.br
(Default = 4, abbreviation = ret)
.IP \fBroot=\fIhost\fR
Change the name of the root server to \fIhost\fP. This
affects the \fBroot\fP command.
.br
(Default = ns.internic.net., abbreviation = ro)
.IP \fBtimeout=\fInumber\fR
Change the initial timeout interval
for waiting for a reply
to \fInumber\fP seconds.
Each retry doubles the timeout period.
.br
(Default = 5 seconds, abbreviation = ti)
.IP "\fB[no]vc\fP"
Always use a virtual circuit when sending requests to the server.
.br
(Default = novc, abbreviation = [no]v)
.IP "\fB[no]ignoretc\fP"
Ignore packet truncation errors.
.br
(Default = noignoretc, abbreviation = [no]ig)
.RE
.SH DIAGNOSTICS
If the lookup request was not successful, an error message is printed.
Possible errors are:
.IP "Timed out" 5
The server did not respond to a request after a certain amount of
time (changed with \fBset timeout=\fIvalue\fR)
and a certain number of retries (changed with \fBset retry=\fIvalue\fR).
.IP "No response from server" 5
No name server is running on the server machine.
.IP "No records" 5
The server does not have resource records of the current query type for the
host, although the host name is valid.
The query type is specified with the \fBset querytype\fP command.
.IP "Non-existent domain" 5
The host or domain name does not exist.
.IP "Connection refused" 5
.ns
.IP "Network is unreachable" 5
The connection to the name or finger server could not be made
at the current time.
This error commonly occurs with \fBls\fP and \fBfinger\fP requests.
.IP "Server failure" 5
The name server found an internal inconsistency in its database
and could not return a valid answer.
.IP "Refused" 5
The name server refused to service the request.
.IP "Format error" 5
The name server found that the request packet was not in the proper format.
It may indicate an error in \fInslookup\fP.
.sp 1
.SH FILES
.ta \w'/usr/share/misc/nslookup.helpXXX'u
/etc/resolv.conf initial domain name and
name server addresses.
.br
$HOME/.nslookuprc user's initial options.
.br
/usr/share/misc/nslookup.help summary of commands.
.SH ENVIRONMENT
.ta \w'HOSTALIASESXXXX'u
HOSTALIASES file containing host aliases.
.br
LOCALDOMAIN overrides default domain.
.SH SEE ALSO
resolver(3), resolver(5), named(8),
.br
RFC-1034 ``Domain Names \- Concepts and Facilities''
.br
RFC-1035 ``Domain Names \- Implementation and Specification''
.SH AUTHOR
Andrew Cherenson

33
usr.sbin/nslookup/nslookup.help
View File

@ -1,33 +0,0 @@
$Id: nslookup.help,v 1.1.1.2 1995/08/18 22:31:32 peter Exp $
Commands: (identifiers are shown in uppercase, [] means optional)
NAME - print info about the host/domain NAME using default server
NAME1 NAME2 - as above, but use NAME2 as server
help or ? - print info on common commands; see nslookup(1) for details
set OPTION - set an option
all - print options, current server and host
[no]debug - print debugging information
[no]d2 - print exhaustive debugging information
[no]defname - append domain name to each query
[no]recurse - ask for recursive answer to query
[no]vc - always use a virtual circuit
domain=NAME - set default domain name to NAME
srchlist=N1[/N2/.../N6] - set domain to N1 and search list to N1,N2, etc.
root=NAME - set root server to NAME
retry=X - set number of retries to X
timeout=X - set initial time-out interval to X seconds
querytype=X - set query type, e.g., A,ANY,CNAME,HINFO,MX,PX,NS,PTR,SOA,TXT,WKS
type=X - synonym for querytype
class=X - set query class to one of IN (Internet), CHAOS, HESIOD or ANY
server NAME - set default server to NAME, using current default server
lserver NAME - set default server to NAME, using initial server
finger [USER] - finger the optional USER at the current default host
root - set current default server to the root
ls [opt] DOMAIN [> FILE] - list addresses in DOMAIN (optional: output to FILE)
-a - list canonical names and aliases
-h - list HINFO (CPU type and operating system)
-s - list well-known services
-d - list all records
-t TYPE - list records of the given type (e.g., A,CNAME,MX, etc.)
view FILE - sort an 'ls' output file and view it with more
exit - exit the program, ^D also exits

66
usr.sbin/nslookup/pathnames.h
View File

@ -1,66 +0,0 @@
/*
* ++Copyright++ 1990
* -
* Copyright (c) 1990
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
/*
* @(#)pathnames.h 5.1 (Berkeley) 5/28/90
* $Id: pathnames.h,v 1.2 1994/09/22 21:50:37 pst Exp $
*/
#define _PATH_NSLOOKUPRC "/.nslookuprc"
#define _PATH_PAGERCMD "more"
#ifndef _PATH_HELPFILE
#define _PATH_HELPFILE "/usr/share/misc/nslookup.help"
#endif

172
usr.sbin/nslookup/res.h
View File

@ -1,172 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
/*
* @(#)res.h 5.10 (Berkeley) 6/1/90
* $Id: res.h,v 1.1.1.1 1994/09/22 21:36:02 pst Exp $
*/
/*
*******************************************************************************
*
* res.h --
*
* Definitions used by modules of the name server lookup program.
*
* Copyright (c) 1985
* Andrew Cherenson
* U.C. Berkeley
* CS298-26 Fall 1985
*
*******************************************************************************
*/
#define TRUE 1
#define FALSE 0
typedef int Boolean;
/*
* Define return statuses in addtion to the ones defined in namserv.h
* let SUCCESS be a synonym for NOERROR
*
* TIME_OUT - a socket connection timed out.
* NO_INFO - the server didn't find any info about the host.
* ERROR - one of the following types of errors:
* dn_expand, res_mkquery failed
* bad command line, socket operation failed, etc.
* NONAUTH - the server didn't have the desired info but
* returned the name(s) of some servers who should.
* NO_RESPONSE - the server didn't respond.
*
*/
#define SUCCESS 0
#define TIME_OUT -1
#define NO_INFO -2
#define ERROR -3
#define NONAUTH -4
#define NO_RESPONSE -5
/*
* Define additional options for the resolver state structure.
*
* RES_DEBUG2 more verbose debug level
*/
#define RES_DEBUG2 0x80000000
/*
* Maximum length of server, host and file names.
*/
#define NAME_LEN 256
/*
* Modified struct hostent from <netdb.h>
*
* "Structures returned by network data base library. All addresses
* are supplied in host order, and returned in network order (suitable
* for use in system calls)."
*/
typedef struct {
char *name; /* official name of host */
char **domains; /* domains it serves */
char **addrList; /* list of addresses from name server */
} ServerInfo;
typedef struct {
char *name; /* official name of host */
char **aliases; /* alias list */
char **addrList; /* list of addresses from name server */
int addrType; /* host address type */
int addrLen; /* length of address */
ServerInfo **servers;
} HostInfo;
/*
* FilePtr is used for directing listings to a file.
* It is global so the Control-C handler can close it.
*/
extern FILE *filePtr;
/*
* TCP/UDP port of server.
*/
extern unsigned short nsport;
/*
* External routines:
*/
extern Boolean IsAddr();
extern int Print_query();
extern unsigned char *Print_cdname();
extern unsigned char *Print_cdname2(); /* fixed width */
extern unsigned char *Print_rr();
extern char *DecodeType(); /* descriptive version of p_type */
extern char *DecodeError();
extern char *Calloc();
extern char *Malloc();
extern void NsError();
extern void PrintServer();
extern void PrintHostInfo();
extern void ShowOptions();
extern void FreeHostInfoPtr();
extern FILE *OpenFile();
extern char *res_skip();

411
usr.sbin/nslookup/send.c
View File

@ -1,411 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)send.c 5.18 (Berkeley) 3/2/91";
static char rcsid[] = "$Id: send.c,v 1.2 1994/09/22 21:50:38 pst Exp $";
#endif /* not lint */
/*
******************************************************************************
*
* send.c --
*
* Routine to send request packets to a name server.
*
* Based on "@(#)res_send.c 6.25 (Berkeley) 6/1/90".
*
******************************************************************************
*/
/*
* Send query to name server and wait for reply.
*/
#include <sys/param.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <arpa/nameser.h>
#include <arpa/inet.h>
#include <resolv.h>
#include "res.h"
static int s = -1; /* socket used for communications */
#ifndef FD_SET
#define NFDBITS 32
#define FD_SETSIZE 32
#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
#define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
#endif
unsigned short nsport = NAMESERVER_PORT;
/*
******************************************************************************
*
* SendRequest --
*
* Sends a request packet to a name server whose address
* is specified by the first argument and returns with
* the answer packet.
*
* Results:
* SUCCESS - the request was sent and an answer
* was received.
* TIME_OUT - the virtual circuit connection timed-out
* or a reply to a datagram wasn't received.
*
*
******************************************************************************
*/
int
SendRequest(nsAddrPtr, buf, buflen, answer, anslen, trueLenPtr)
struct in_addr *nsAddrPtr;
char *buf;
int buflen;
char *answer;
u_int anslen;
int *trueLenPtr;
{
register int n;
int try, v_circuit, resplen;
int gotsomewhere = 0, connected = 0;
int connreset = 0;
u_short id, len;
char *cp;
fd_set dsmask;
struct timeval timeout;
HEADER *hp = (HEADER *) buf;
HEADER *anhp = (HEADER *) answer;
struct iovec iov[2];
int terrno = ETIMEDOUT;
char junk[512];
struct sockaddr_in sin;
if (_res.options & RES_DEBUG2) {
printf("------------\nSendRequest(), len %d\n", buflen);
Print_query(buf, buf+buflen, 1);
}
sin.sin_family = AF_INET;
sin.sin_port = htons(nsport);
sin.sin_addr = *nsAddrPtr;
v_circuit = (_res.options & RES_USEVC) || buflen > PACKETSZ;
id = hp->id;
/*
* Send request, RETRY times, or until successful
*/
for (try = 0; try < _res.retry; try++) {
usevc:
if (v_circuit) {
int truncated = 0;
/*
* Use virtual circuit;
* at most one attempt per server.
*/
try = _res.retry;
if (s < 0) {
s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("socket (vc) failed");
continue;
}
if (connect(s, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) < 0) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("connect failed");
(void) close(s);
s = -1;
continue;
}
}
/*
* Send length & message
*/
__putshort(buflen, (u_char *)&len);
iov[0].iov_base = (caddr_t)&len;
iov[0].iov_len = INT16SZ;
iov[1].iov_base = buf;
iov[1].iov_len = buflen;
if (writev(s, iov, 2) != INT16SZ + buflen) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("write failed");
(void) close(s);
s = -1;
continue;
}
/*
* Receive length & response
*/
cp = answer;
len = INT16SZ;
while ((n = read(s, (char *)cp, (int)len)) > 0) {
cp += n;
if ((len -= n) <= 0)
break;
}
if (n <= 0) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("read failed");
(void) close(s);
s = -1;
/*
* A long running process might get its TCP
* connection reset if the remote server was
* restarted. Requery the server instead of
* trying a new one. When there is only one
* server, this means that a query might work
* instead of failing. We only allow one reset
* per query to prevent looping.
*/
if (terrno == ECONNRESET && !connreset) {
connreset = 1;
}
continue;
}
cp = answer;
if ((resplen = _getshort((u_char*)cp)) > anslen) {
if (_res.options & RES_DEBUG)
fprintf(stderr, "response truncated\n");
len = anslen;
truncated = 1;
} else
len = resplen;
while (len != 0 &&
(n = read(s, (char *)cp, (int)len)) > 0) {
cp += n;
len -= n;
}
if (n <= 0) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("read failed");
(void) close(s);
s = -1;
continue;
}
if (truncated) {
/*
* Flush rest of answer
* so connection stays in synch.
*/
anhp->tc = 1;
len = resplen - anslen;
while (len != 0) {
n = (len > sizeof(junk) ?
sizeof(junk) : len);
if ((n = read(s, junk, n)) > 0)
len -= n;
else
break;
}
}
} else {
/*
* Use datagrams.
*/
if (s < 0) {
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) {
terrno = errno;
if (_res.options & RES_DEBUG)
perror("socket (dg) failed");
continue;
}
}
#if BSD >= 43
if (connected == 0) {
if (connect(s, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) < 0) {
if (_res.options & RES_DEBUG)
perror("connect");
continue;
}
connected = 1;
}
if (send(s, buf, buflen, 0) != buflen) {
if (_res.options & RES_DEBUG)
perror("send");
continue;
}
#else /* BSD */
if (sendto(s, buf, buflen, 0,
(struct sockaddr *) &sin,
sizeof(sin)) != buflen) {
if (_res.options & RES_DEBUG)
perror("sendto");
continue;
}
#endif
/*
* Wait for reply
*/
timeout.tv_sec = (_res.retrans << try);
if (timeout.tv_sec <= 0)
timeout.tv_sec = 1;
timeout.tv_usec = 0;
wait:
FD_ZERO(&dsmask);
FD_SET(s, &dsmask);
n = select(s+1, &dsmask, (fd_set *)NULL,
(fd_set *)NULL, &timeout);
if (n < 0) {
if (_res.options & RES_DEBUG)
perror("select");
continue;
}
if (n == 0) {
/*
* timeout
*/
if (_res.options & RES_DEBUG)
printf("timeout (%d secs)\n",
timeout.tv_sec);
#if BSD >= 43
gotsomewhere = 1;
#endif
continue;
}
if ((resplen = recv(s, answer, anslen, 0)) <= 0) {
if (_res.options & RES_DEBUG)
perror("recvfrom");
continue;
}
gotsomewhere = 1;
if (id != anhp->id) {
/*
* response from old query, ignore it
*/
if (_res.options & RES_DEBUG2) {
printf("------------\nOld answer:\n");
Print_query(answer, answer+resplen, 1);
}
goto wait;
}
if (!(_res.options & RES_IGNTC) && anhp->tc) {
/*
* get rest of answer;
* use TCP with same server.
*/
if (_res.options & RES_DEBUG)
printf("truncated answer\n");
(void) close(s);
s = -1;
v_circuit = 1;
goto usevc;
}
}
if (_res.options & RES_DEBUG) {
if (_res.options & RES_DEBUG2)
printf("------------\nGot answer (%d bytes):\n",
resplen);
else
printf("------------\nGot answer:\n");
Print_query(answer, answer+resplen, 1);
}
(void) close(s);
s = -1;
*trueLenPtr = resplen;
return (SUCCESS);
}
if (s >= 0) {
(void) close(s);
s = -1;
}
if (v_circuit == 0)
if (gotsomewhere == 0)
return NO_RESPONSE; /* no nameservers found */
else
return TIME_OUT; /* no answer obtained */
else
if (errno == ECONNREFUSED)
return NO_RESPONSE;
else
return ERROR;
}
/*
* This routine is for closing the socket if a virtual circuit is used and
* the program wants to close it.
*
* Called from the interrupt handler.
*/
SendRequest_close()
{
if (s != -1) {
(void) close(s);
s = -1;
}
}

210
usr.sbin/nslookup/skip.c
View File

@ -1,210 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)skip.c 5.12 (Berkeley) 3/21/91";
static char rcsid[] = "$Id: skip.c,v 1.2 1994/09/22 21:50:39 pst Exp $";
#endif /* not lint */
/*
*******************************************************************************
*
* skip.c --
*
* Routines to skip over portions of a query buffer.
*
* Note: this file has been submitted for inclusion in
* BIND resolver library. When this has been done, this file
* is no longer necessary (assuming there haven't been any
* changes).
*
* Adapted from 4.3BSD BIND res_debug.c
*
*******************************************************************************
*/
#include <sys/param.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <stdio.h>
char *res_skip_rr();
/*
*******************************************************************************
*
* res_skip --
*
* Skip the contents of a query.
*
* Interpretation of numFieldsToSkip argument:
* res_skip returns pointer to:
* 1 -> start of question records.
* 2 -> start of authoritative answer records.
* 3 -> start of additional records.
* 4 -> first byte after end of additional records.
*
* Results:
* (address) - success operation.
* NULL - a resource record had an incorrect format.
*
*******************************************************************************
*/
char *
res_skip(msg, numFieldsToSkip, eom)
char *msg;
int numFieldsToSkip;
char *eom;
{
register char *cp;
register HEADER *hp;
register int tmp;
register int n;
/*
* Skip the header fields.
*/
hp = (HEADER *)msg;
cp = msg + HFIXEDSZ;
/*
* skip question records.
*/
if (n = ntohs(hp->qdcount) ) {
while (--n >= 0 && cp < eom) {
tmp = dn_skipname((u_char *)cp, (u_char *)eom);
if (tmp == -1) return(NULL);
cp += tmp;
cp += INT16SZ; /* type */
cp += INT16SZ; /* class */
}
}
if (--numFieldsToSkip <= 0) return(cp);
/*
* skip authoritative answer records
*/
if (n = ntohs(hp->ancount)) {
while (--n >= 0 && cp < eom) {
cp = res_skip_rr(cp, eom);
if (cp == NULL) return(NULL);
}
}
if (--numFieldsToSkip == 0) return(cp);
/*
* skip name server records
*/
if (n = ntohs(hp->nscount)) {
while (--n >= 0 && cp < eom) {
cp = res_skip_rr(cp, eom);
if (cp == NULL) return(NULL);
}
}
if (--numFieldsToSkip == 0) return(cp);
/*
* skip additional records
*/
if (n = ntohs(hp->arcount)) {
while (--n >= 0 && cp < eom) {
cp = res_skip_rr(cp, eom);
if (cp == NULL) return(NULL);
}
}
return(cp);
}
/*
*******************************************************************************
*
* res_skip_rr --
*
* Skip over resource record fields.
*
* Results:
* (address) - success operation.
* NULL - a resource record had an incorrect format.
*******************************************************************************
*/
char *
res_skip_rr(cp, eom)
char *cp;
char *eom;
{
int tmp;
int dlen;
if ((tmp = dn_skipname((u_char *)cp, (u_char *)eom)) == -1)
return (NULL); /* compression error */
cp += tmp;
if ((cp + RRFIXEDSZ) > eom)
return (NULL);
cp += INT16SZ; /* type */
cp += INT16SZ; /* class */
cp += INT32SZ; /* ttl */
dlen = _getshort((u_char*)cp);
cp += INT16SZ; /* dlen */
cp += dlen;
if (cp > eom)
return (NULL);
return (cp);
}

579
usr.sbin/nslookup/subr.c
View File

@ -1,579 +0,0 @@
/*
* ++Copyright++ 1985, 1989
* -
* Copyright (c) 1985, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* -
* --Copyright--
*/
#ifndef lint
static char sccsid[] = "@(#)subr.c 5.24 (Berkeley) 3/2/91";
static char rcsid[] = "$Id: subr.c,v 1.5 1995/10/23 12:59:29 peter Exp $";
#endif /* not lint */
/*
*******************************************************************************
*
* subr.c --
*
* Miscellaneous subroutines for the name server
* lookup program.
*
* Copyright (c) 1985
* Andrew Cherenson
* U.C. Berkeley
* CS298-26 Fall 1985
*
*******************************************************************************
*/
#include <sys/types.h>
#include <sys/param.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <arpa/inet.h>
#include <signal.h>
#include <setjmp.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "res.h"
/*
*******************************************************************************
*
* IntrHandler --
*
* This routine is called whenever a control-C is typed.
* It performs three main functions:
* - closes an open socket connection,
* - closes an open output file (used by LookupHost, et al.),
* - jumps back to the main read-eval loop.
*
* If a user types a ^C in the middle of a routine that uses a socket,
* the routine would not be able to close the socket. To prevent an
* overflow of the process's open file table, the socket and output
* file descriptors are closed by the interrupt handler.
*
* Side effects:
* Open file descriptors are closed.
* If filePtr is valid, it is closed.
* Flow of control returns to the main() routine.
*
*******************************************************************************
*/
void
IntrHandler()
{
extern jmp_buf env;
#if defined(BSD) && BSD >= 199006 && !defined(RISCOS_BSD) && !defined(__osf__)
extern FILE *yyin; /* scanner input file */
extern void yyrestart(); /* routine to restart scanner after interrupt */
#endif
SendRequest_close();
ListHost_close();
if (filePtr != NULL && filePtr != stdout) {
fclose(filePtr);
filePtr = NULL;
}
printf("\n");
#if defined(BSD) && BSD >= 199006 && !defined(RISCOS_BSD) && !defined(__osf__)
yyrestart(yyin);
#endif
longjmp(env, 1);
}
/*
*******************************************************************************
*
* Malloc --
* Calloc --
*
* Calls the malloc library routine with SIGINT blocked to prevent
* corruption of malloc's data structures. We need to do this because
* a control-C doesn't kill the program -- it causes a return to the
* main command loop.
*
* NOTE: This method doesn't prevent the pointer returned by malloc
* from getting lost, so it is possible to get "core leaks".
*
* If malloc fails, the program exits.
*
* Results:
* (address) - address of new buffer.
*
*******************************************************************************
*/
char *
Malloc(size)
int size;
{
char *ptr;
#ifdef SYSV
#if defined(SVR3) || defined(SVR4)
sighold(SIGINT);
ptr = malloc((unsigned) size);
sigrelse(SIGINT);
#else
{ void (*old)();
old = signal(SIGINT, SIG_IGN);
ptr = malloc((unsigned) size);
signal(SIGINT, old);
}
#endif
#else
#ifdef POSIX_SIGNALS
{ sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset,SIGINT);
sigprocmask(SIG_BLOCK,&sset,NULL);
ptr = malloc((unsigned) size);
sigprocmask(SIG_UNBLOCK,&sset,NULL);
}
#else
{ int saveMask;
saveMask = sigblock(sigmask(SIGINT));
ptr = malloc((unsigned) size);
(void) sigsetmask(saveMask);
}
#endif
#endif
if (ptr == NULL) {
fflush(stdout);
fprintf(stderr, "*** Can't allocate memory\n");
fflush(stderr);
abort();
/*NOTREACHED*/
} else {
return(ptr);
}
}
char *
Calloc(num, size)
register int num, size;
{
char *ptr = Malloc(num*size);
bzero(ptr, num*size);
return(ptr);
}
/*
*******************************************************************************
*
* PrintHostInfo --
*
* Prints out the HostInfo structure for a host.
*
*******************************************************************************
*/
void
PrintHostInfo(file, title, hp)
FILE *file;
char *title;
register HostInfo *hp;
{
register char **cp;
register ServerInfo **sp;
char comma;
int i;
fprintf(file, "%-7s %s", title, hp->name);
if (hp->addrList != NULL) {
if (hp->addrList[1] != NULL) {
fprintf(file, "\nAddresses:");
} else {
fprintf(file, "\nAddress:");
}
comma = ' ';
i = 0;
for (cp = hp->addrList; cp && *cp; cp++) {
i++;
if (i > 4) {
fprintf(file, "\n\t");
comma = ' ';
i = 0;
}
fprintf(file,"%c %s", comma, inet_ntoa(*(struct in_addr *)*cp));
comma = ',';
}
}
if (hp->aliases != NULL) {
fprintf(file, "\nAliases:");
comma = ' ';
i = 10;
for (cp = hp->aliases; cp && *cp && **cp; cp++) {
i += strlen(*cp) + 2;
if (i > 75) {
fprintf(file, "\n\t");
comma = ' ';
i = 10;
}
fprintf(file, "%c %s", comma, *cp);
comma = ',';
}
}
if (hp->servers != NULL) {
fprintf(file, "\nServed by:\n");
for (sp = hp->servers; *sp != NULL ; sp++) {
fprintf(file, "- %s\n\t", (*sp)->name);
comma = ' ';
i = 0;
for (cp = (*sp)->addrList; cp && *cp && **cp; cp++) {
i++;
if (i > 4) {
fprintf(file, "\n\t");
comma = ' ';
i = 0;
}
fprintf(file,
"%c %s", comma, inet_ntoa(*(struct in_addr *)*cp));
comma = ',';
}
fprintf(file, "\n\t");
comma = ' ';
i = 10;
for (cp = (*sp)->domains; cp && *cp && **cp; cp++) {
i += strlen(*cp) + 2;
if (i > 75) {
fprintf(file, "\n\t");
comma = ' ';
i = 10;
}
fprintf(file, "%c %s", comma, *cp);
comma = ',';
}
fprintf(file, "\n");
}
}
fprintf(file, "\n\n");
}
/*
*******************************************************************************
*
* OpenFile --
*
* Parses a command string for a file name and opens
* the file.
*
* Results:
* file pointer - the open was successful.
* NULL - there was an error opening the file or
* the input string was invalid.
*
*******************************************************************************
*/
FILE *
OpenFile(string, file)
char *string;
char *file;
{
char *redirect;
FILE *tmpPtr;
/*
* Open an output file if we see '>' or >>'.
* Check for overwrite (">") or concatenation (">>").
*/
redirect = strchr(string, '>');
if (redirect == NULL) {
return(NULL);
}
if (redirect[1] == '>') {
sscanf(redirect, ">> %s", file);
tmpPtr = fopen(file, "a+");
} else {
sscanf(redirect, "> %s", file);
tmpPtr = fopen(file, "w");
}
if (tmpPtr != NULL) {
redirect[0] = '\0';
}
return(tmpPtr);
}
/*
*******************************************************************************
*
* DecodeError --
*
* Converts an error code into a character string.
*
*******************************************************************************
*/
char *
DecodeError(result)
int result;
{
switch (result) {
case NOERROR: return("Success"); break;
case FORMERR: return("Format error"); break;
case SERVFAIL: return("Server failed"); break;
case NXDOMAIN: return("Non-existent host/domain"); break;
case NOTIMP: return("Not implemented"); break;
case REFUSED: return("Query refused"); break;
#ifdef NOCHANGE
case NOCHANGE: return("No change"); break;
#endif
case TIME_OUT: return("Timed out"); break;
case NO_INFO: return("No information"); break;
case ERROR: return("Unspecified error"); break;
case NONAUTH: return("Non-authoritative answer"); break;
case NO_RESPONSE: return("No response from server"); break;
default: break;
}
return("BAD ERROR VALUE");
}
int
StringToClass(class, dflt, errorfile)
char *class;
int dflt;
FILE *errorfile;
{
if (strcasecmp(class, "IN") == 0)
return(C_IN);
if (strcasecmp(class, "HESIOD") == 0 ||
strcasecmp(class, "HS") == 0)
return(C_HS);
if (strcasecmp(class, "CHAOS") == 0)
return(C_CHAOS);
if (strcasecmp(class, "ANY") == 0)
return(C_ANY);
if (errorfile)
fprintf(errorfile, "unknown query class: %s\n", class);
return(dflt);
}
/*
*******************************************************************************
*
* StringToType --
*
* Converts a string form of a query type name to its
* corresponding integer value.
*
*******************************************************************************
*/
int
StringToType(type, dflt, errorfile)
char *type;
int dflt;
FILE *errorfile;
{
if (strcasecmp(type, "A") == 0)
return(T_A);
if (strcasecmp(type, "NS") == 0)
return(T_NS); /* authoritative server */
if (strcasecmp(type, "MX") == 0)
return(T_MX); /* mail exchanger */
if (strcasecmp(type, "PX") == 0)
return(T_PX); /* mapping information */
if (strcasecmp(type, "CNAME") == 0)
return(T_CNAME); /* canonical name */
if (strcasecmp(type, "SOA") == 0)
return(T_SOA); /* start of authority zone */
if (strcasecmp(type, "MB") == 0)
return(T_MB); /* mailbox domain name */
if (strcasecmp(type, "MG") == 0)
return(T_MG); /* mail group member */
if (strcasecmp(type, "MR") == 0)
return(T_MR); /* mail rename name */
if (strcasecmp(type, "WKS") == 0)
return(T_WKS); /* well known service */
if (strcasecmp(type, "PTR") == 0)
return(T_PTR); /* domain name pointer */
if (strcasecmp(type, "HINFO") == 0)
return(T_HINFO); /* host information */
if (strcasecmp(type, "MINFO") == 0)
return(T_MINFO); /* mailbox information */
if (strcasecmp(type, "AXFR") == 0)
return(T_AXFR); /* zone transfer */
if (strcasecmp(type, "MAILA") == 0)
return(T_MAILA); /* mail agent */
if (strcasecmp(type, "MAILB") == 0)
return(T_MAILB); /* mail box */
if (strcasecmp(type, "ANY") == 0)
return(T_ANY); /* matches any type */
if (strcasecmp(type, "UINFO") == 0)
return(T_UINFO); /* user info */
if (strcasecmp(type, "UID") == 0)
return(T_UID); /* user id */
if (strcasecmp(type, "GID") == 0)
return(T_GID); /* group id */
if (strcasecmp(type, "TXT") == 0)
return(T_TXT); /* text */
if (strcasecmp(type, "RP") == 0)
return(T_RP); /* responsible person */
if (strcasecmp(type, "X25") == 0)
return(T_X25); /* x25 address */
if (strcasecmp(type, "ISDN") == 0)
return(T_ISDN); /* isdn address */
if (strcasecmp(type, "RT") == 0)
return(T_RT); /* router */
if (strcasecmp(type, "AFSDB") == 0)
return(T_AFSDB); /* DCE or AFS server */
if (strcasecmp(type, "NSAP") == 0)
return(T_NSAP); /* NSAP address */
if (strcasecmp(type, "NSAP_PTR") == 0)
return(T_NSAP_PTR); /* NSAP reverse pointer */
if (errorfile)
fprintf(errorfile, "unknown query type: %s\n", type);
return(dflt);
}
/*
*******************************************************************************
*
* DecodeType --
*
* Converts a query type to a descriptive name.
* (A more verbose form of p_type.)
*
*
*******************************************************************************
*/
static char nbuf[20];
char *
DecodeType(type)
int type;
{
switch (type) {
case T_A:
return("address");
case T_NS:
return("name server");
case T_CNAME:
return("canonical name");
case T_SOA:
return("start of authority");
case T_MB:
return("mailbox");
case T_MG:
return("mail group member");
case T_MR:
return("mail rename");
case T_NULL:
return("null");
case T_WKS:
return("well-known service");
case T_PTR:
return("domain name pointer");
case T_HINFO:
return("host information");
case T_MINFO:
return("mailbox information");
case T_MX:
return("mail exchanger");
case T_PX:
return("mapping information");
case T_TXT:
return("text");
case T_RP:
return("responsible person");
case T_AFSDB:
return("DCE or AFS server");
case T_X25:
return("X25 address");
case T_ISDN:
return("ISDN address");
case T_RT:
return("router");
case T_NSAP:
return("nsap address");
case T_NSAP_PTR:
return("domain name pointer");
case T_UINFO:
return("user information");
case T_UID:
return("user ID");
case T_GID:
return("group ID");
case T_AXFR:
return("zone transfer");
case T_MAILB:
return("mailbox-related data");
case T_MAILA:
return("mail agent");
case T_ANY:
return("\"any\"");
default:
(void) sprintf(nbuf, "%d", type);
return (nbuf);
}
}