/* $NetBSD: list.c,v 1.1.1.1 1998/10/05 18:01:59 tron Exp $ */ /* * 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. */ #ifndef lint static char sccsid[] = "@(#)list.c 5.23 (Berkeley) 3/21/91"; static char rcsid[] = "Id: list.c,v 8.13 1997/11/18 00:32:33 halley Exp"; #endif /* not lint */ /* ******************************************************************************* * * list.c -- * * Routines to obtain info from name and finger servers. * * Adapted from 4.3BSD BIND ns_init.c and from finger.c. * ******************************************************************************* */ #include "port_before.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "port_after.h" #include "res.h" extern char *_res_resultcodes[]; /* res_debug.c */ extern char *pager; typedef union { HEADER qb1; u_char qb2[PACKETSZ]; } querybuf; extern HostInfo *defaultPtr; extern HostInfo curHostInfo; extern int curHostValid; extern int queryType; extern int queryClass; static int sockFD = -1; int ListSubr(); /* * During a listing to a file, hash marks are printed * every HASH_SIZE records. */ #define HASH_SIZE 50 /* ******************************************************************************* * * ListHosts -- * ListHostsByType -- * * Requests the name server to do a zone transfer so we * find out what hosts it knows about. * * For ListHosts, there are five types of output: * - Internet addresses (default) * - cpu type and operating system (-h option) * - canonical and alias names (-a option) * - well-known service names (-s option) * - ALL records (-d option) * ListHostsByType prints records of the default type or of a speicific * type. * * To see all types of information sorted by name, do the following: * ls -d domain.edu > file * view file * * Results: * SUCCESS the listing was successful. * ERROR the server could not be contacted because * a socket could not be obtained or an error * occured while receiving, or the output file * could not be opened. * ******************************************************************************* */ void ListHostsByType(char *string, int putToFile) { char *namePtr, name[NAME_LEN], option[NAME_LEN]; int i, qtype, result; /* * Parse the command line. It maybe of the form "ls -t domain" * or "ls -t type domain". */ i = sscanf(string, " ls -t %s %s", option, name); if (putToFile && i == 2 && name[0] == '>') i--; if (i == 2) { qtype = StringToType(option, -1, stderr); if (qtype == -1) return; namePtr = name; } else if (i == 1) { namePtr = option; qtype = queryType; } else { fprintf(stderr, "*** ls: invalid request %s\n", string); return; } result = ListSubr(qtype, namePtr, putToFile ? string : NULL); if (result != SUCCESS) fprintf(stderr, "*** Can't list domain %s: %s\n", namePtr, DecodeError(result)); } void ListHosts(char *string, int putToFile) { char *namePtr, name[NAME_LEN], option[NAME_LEN]; int i, qtype, result; /* * Parse the command line. It maybe of the form "ls domain", * "ls -X domain". */ i = sscanf(string, " ls %s %s", option, name); if (putToFile && i == 2 && name[0] == '>') i--; if (i == 2) { if (strcmp("-a", option) == 0) qtype = T_CNAME; else if (strcmp("-h", option) == 0) qtype = T_HINFO; else if (strcmp("-m", option) == 0) qtype = T_MX; else if (strcmp("-p", option) == 0) qtype = T_PX; else if (strcmp("-s", option) == 0) qtype = T_WKS; else if (strcmp("-d", option) == 0) qtype = T_ANY; else if (strcmp("-n", option) == 0) qtype = T_NAPTR; else qtype = T_A; namePtr = name; } else if (i == 1) { namePtr = option; qtype = T_A; } else { fprintf(stderr, "*** ls: invalid request %s\n",string); return; } result = ListSubr(qtype, namePtr, putToFile ? string : NULL); if (result != SUCCESS) fprintf(stderr, "*** Can't list domain %s: %s\n", namePtr, DecodeError(result)); } int ListSubr(int qtype, char *domain, char *cmd) { static u_char *answer = NULL; static int answerLen = 0; ns_msg handle; querybuf buf; struct sockaddr_in sin; HEADER *headerPtr; int msglen, amtToRead, numRead, n, count, soacnt; u_int len; int numAnswers = 0; int numRecords = 0; u_char tmp[INT16SZ], *cp; char soaname[2][NAME_LEN], file[NAME_LEN]; enum { NO_ERRORS, ERR_READING_LEN, ERR_READING_MSG, ERR_PRINTING } error = NO_ERRORS; /* * Create a query packet for the requested domain name. */ msglen = res_mkquery(QUERY, domain, queryClass, T_AXFR, NULL, 0, 0, buf.qb2, sizeof buf); if (msglen < 0) { if (_res.options & RES_DEBUG) fprintf(stderr, "*** ls: res_mkquery failed\n"); return (ERROR); } memset(&sin, 0, sizeof sin); sin.sin_family = AF_INET; sin.sin_port = htons(nsport); /* * Check to see if we have the address of the server or the * address of a server who knows about this domain. * * For now, just use the first address in the list. XXX. */ if (defaultPtr->addrList != NULL) sin.sin_addr = *(struct in_addr *) defaultPtr->addrList[0]; else sin.sin_addr = *(struct in_addr *) defaultPtr->servers[0]->addrList[0]; /* * Set up a virtual circuit to the server. */ sockFD = socket(AF_INET, SOCK_STREAM, 0); if (sockFD < 0) { perror("ls: socket"); return (ERROR); } if (connect(sockFD, (struct sockaddr *)&sin, sizeof(sin)) < 0) { int e; if (errno == ECONNREFUSED) e = NO_RESPONSE; else { perror("ls: connect"); e = ERROR; } (void) close(sockFD); sockFD = -1; return (e); } /* * Send length & message for zone transfer */ ns_put16(msglen, tmp); if (write(sockFD, (char *)tmp, INT16SZ) != INT16SZ || write(sockFD, (char *)buf.qb2, msglen) != msglen) { perror("ls: write"); (void) close(sockFD); sockFD = -1; return(ERROR); } fprintf(stdout,"[%s]\n", (defaultPtr->addrList != NULL) ? defaultPtr->name : defaultPtr->servers[0]->name); if (cmd == NULL) { filePtr = stdout; } else { filePtr = OpenFile(cmd, file); if (filePtr == NULL) { fprintf(stderr, "*** Can't open %s for writing\n", file); (void) close(sockFD); sockFD = -1; return (ERROR); } fprintf(filePtr, "> %s\n", cmd); fprintf(filePtr, "[%s]\n", (defaultPtr->addrList != NULL) ? defaultPtr->name : defaultPtr->servers[0]->name); } soacnt = 0; while (soacnt < 2) { /* * Read the length of the response. */ cp = tmp; amtToRead = INT16SZ; while (amtToRead > 0 && (numRead = read(sockFD, cp, amtToRead)) > 0) { cp += numRead; amtToRead -= numRead; } if (numRead <= 0) { error = ERR_READING_LEN; break; } len = ns_get16(tmp); if (len == 0) break; /* nothing left to read */ /* * If the server sent too much data to fit the existing * buffer, allocate a new one. */ if (len > (u_int)answerLen) { if (answerLen != 0) free(answer); answerLen = len; answer = (u_char *)Malloc(answerLen); } /* * Read the response. */ amtToRead = len; cp = answer; while (amtToRead > 0 && (numRead = read(sockFD, cp, amtToRead)) > 0) { cp += numRead; amtToRead -= numRead; } if (numRead <= 0) { error = ERR_READING_MSG; break; } if (ns_initparse(answer, cp - answer, &handle) < 0) { perror("ns_initparse"); error = ERR_PRINTING; break; } if (ns_msg_getflag(handle, ns_f_rcode) != ns_r_noerror || ns_msg_count(handle, ns_s_an) == 0) { /* Signalled protocol error, or empty message. */ error = ERR_PRINTING; break; } for (;;) { static char origin[NS_MAXDNAME], name_ctx[NS_MAXDNAME]; const char *name; char buf[2048]; /* XXX need to malloc/realloc. */ ns_rr rr; if (ns_parserr(&handle, ns_s_an, -1, &rr)) { if (errno != ENODEV) { perror("ns_parserr"); error = ERR_PRINTING; } break; } name = ns_rr_name(rr); if (origin[0] == '\0' && name[0] != '\0') { fprintf(filePtr, "$ORIGIN %s.\n", name); strcpy(origin, name); } if (qtype == T_ANY || ns_rr_type(rr) == qtype) { if (ns_sprintrr(&handle, &rr, name_ctx, origin, buf, sizeof buf) < 0) { perror("ns_sprintrr"); error = ERR_PRINTING; break; } strcpy(name_ctx, name); numAnswers++; fputs(buf, filePtr); fputc('\n', filePtr); } if (ns_rr_type(rr) == T_SOA) { strcpy(soaname[soacnt], name); if (soacnt == 0) soacnt = 1; else if (strcasecmp(soaname[0], soaname[1]) == 0) { soacnt = 2; } } } if (error != NO_ERRORS) break; numAnswers++; if (cmd != NULL && ((numAnswers % HASH_SIZE) == 0)) { fprintf(stdout, "#"); fflush(stdout); } } if (cmd != NULL) fprintf(stdout, "%sReceived %d answer%s (%d record%s).\n", (numAnswers >= HASH_SIZE) ? "\n" : "", numAnswers, (numAnswers != 1) ? "s" : "", numRecords, (numRecords != 1) ? "s" : ""); (void) close(sockFD); sockFD = -1; if (cmd != NULL && filePtr != NULL) { fclose(filePtr); filePtr = NULL; } switch (error) { case NO_ERRORS: return (SUCCESS); case ERR_READING_LEN: return (ERROR); case ERR_PRINTING: return (ERROR); case ERR_READING_MSG: headerPtr = (HEADER *) answer; fprintf(stderr,"*** ls: error receiving zone transfer:\n"); fprintf(stderr, " result: %s, answers = %d, authority = %d, additional = %d\n", _res_resultcodes[headerPtr->rcode], ntohs(headerPtr->ancount), ntohs(headerPtr->nscount), ntohs(headerPtr->arcount)); return (ERROR); default: return (ERROR); } } /* ******************************************************************************* * * ViewList -- * * A hack to view the output of the ls command in sorted * order using more. * ******************************************************************************* */ ViewList(string) char *string; { char file[PATH_MAX]; char command[PATH_MAX]; sscanf(string, " view %s", file); (void)sprintf(command, "grep \"^ \" %s | sort | %s", file, pager); system(command); } /* ******************************************************************************* * * Finger -- * * Connects with the finger server for the current host * to request info on the specified person (long form) * who is on the system (short form). * * Results: * SUCCESS the finger server was contacted. * ERROR the server could not be contacted because * a socket could not be obtained or connected * to or the service could not be found. * ******************************************************************************* */ Finger(string, putToFile) char *string; int putToFile; { struct servent *sp; struct sockaddr_in sin; FILE *f; int c; int lastc; char name[NAME_LEN]; char file[NAME_LEN]; /* * We need a valid current host info to get an inet address. */ if (!curHostValid) { fprintf(stderr, "Finger: no current host defined.\n"); return (ERROR); } if (sscanf(string, " finger %s", name) == 1) { if (putToFile && (name[0] == '>')) { name[0] = '\0'; } } else { name[0] = '\0'; } sp = getservbyname("finger", "tcp"); if (sp == 0) { fprintf(stderr, "Finger: unknown service\n"); return (ERROR); } memset(&sin, 0, sizeof sin); sin.sin_family = curHostInfo.addrType; sin.sin_port = sp->s_port; memcpy(&sin.sin_addr, curHostInfo.addrList[0], curHostInfo.addrLen); /* * Set up a virtual circuit to the host. */ sockFD = socket(curHostInfo.addrType, SOCK_STREAM, 0); if (sockFD < 0) { fflush(stdout); perror("finger: socket"); return (ERROR); } if (connect(sockFD, (struct sockaddr *)&sin, sizeof (sin)) < 0) { fflush(stdout); perror("finger: connect"); close(sockFD); sockFD = -1; return (ERROR); } if (!putToFile) { filePtr = stdout; } else { filePtr = OpenFile(string, file); if (filePtr == NULL) { fprintf(stderr, "*** Can't open %s for writing\n", file); close(sockFD); sockFD = -1; return(ERROR); } fprintf(filePtr,"> %s\n", string); } fprintf(filePtr, "[%s]\n", curHostInfo.name); if (name[0] != '\0') { write(sockFD, "/W ", 3); } write(sockFD, name, strlen(name)); write(sockFD, "\r\n", 2); f = fdopen(sockFD, "r"); lastc = '\n'; while ((c = getc(f)) != EOF) { switch (c) { case 0210: case 0211: case 0212: case 0214: c -= 0200; break; case 0215: c = '\n'; break; } putc(lastc = c, filePtr); } if (lastc != '\n') { putc('\n', filePtr); } putc('\n', filePtr); close(sockFD); sockFD = -1; if (putToFile) { fclose(filePtr); filePtr = NULL; } return (SUCCESS); } ListHost_close() { if (sockFD != -1) { (void) close(sockFD); sockFD = -1; } }