![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to list.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc / named / tools / ns.lookup / src|
Return to list.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / named / tools / ns.lookup / src |
1.1 root 1: /*
2: *******************************************************************************
3: *
4: * list.c --
5: *
6: * Routines to obtain info from name and finger servers.
7: *
8: * Adapted from 4.3BSD BIND ns_init.c and from /usr/src/ucb/finger.c
9: *
10: * Copyright (c) 1985 Regents of the University of California.
11: * All rights reserved. The Berkeley software License Agreement
12: * specifies the terms and conditions for redistribution.
13: *
14: *******************************************************************************
15: */
16:
17: #ifndef lint
18: static char sccsid[] = "@(#)list.c 5.4 (Berkeley) 4/10/86";
19: #endif not lint
20:
21: #include <sys/types.h>
22: #include <sys/socket.h>
23: #include <netinet/in.h>
24: #include <netdb.h>
25: #include <stdio.h>
26: #include <strings.h>
27: #include <ctype.h>
28: #include <arpa/nameser.h>
29: #include <resolv.h>
30: #include "res.h"
31:
32: /*
33: * Imported from res_debug.c
34: */
35: extern char *rcodes[];
36:
37: typedef union {
38: HEADER qb1;
39: char qb2[PACKETSZ];
40: } querybuf;
41:
42: extern u_long inet_addr();
43: extern HostInfo *defaultPtr;
44: extern HostInfo curHostInfo;
45: extern int curHostValid;
46:
47: /*
48: * During a listing to a file, hash marks are printed
49: * every HASH_SIZE records.
50: */
51:
52: #define HASH_SIZE 50
53:
54:
55: /*
56: *******************************************************************************
57: *
58: * ListHosts --
59: *
60: * Requests the name server to do a zone transfer so we
61: * find out what hosts it knows about.
62: *
63: * There are three types of output:
64: * - internet addresses (default)
65: * - cpu type and operating system (-h option)
66: * - canonical and alias names (-a option)
67: *
68: * To see all three types of information in sorted order,
69: * do the following:
70: * ls domain.edu > file
71: * ls -a domain.edu >> file
72: * ls -h domain.edu >> file
73: * view file
74: *
75: * Results:
76: * SUCCESS the listing was successful.
77: * ERROR the server could not be contacted because
78: * a socket could not be obtained or an error
79: * occured while receiving, or the output file
80: * could not be opened.
81: *
82: *******************************************************************************
83: */
84:
85: int
86: ListHosts(string, putToFile)
87: char *string;
88: int putToFile;
89: {
90: querybuf buf;
91: struct sockaddr_in sin;
92: HEADER *headerPtr;
93: int queryType;
94: int msglen;
95: int amtToRead;
96: int numRead;
97: int i;
98: int numAnswers = 0;
99: int result;
100: int soacnt = 0;
101: u_short len;
102: char *cp;
103: char name[NAME_LEN];
104: char option[NAME_LEN];
105: char file[NAME_LEN];
106: char *namePtr;
107: enum {
108: NO_ERRORS,
109: ERR_READING_LEN,
110: ERR_READING_MSG,
111: ERR_PRINTING,
112: } error = NO_ERRORS;
113:
114:
115: /*
116: *
117: /*
118: * Parse the command line. It maybe of the form "ls domain",
119: * "ls -a domain" or "ls -h domain".
120: */
121: i = sscanf(string, " ls %s %s", option, name);
122: if (putToFile && i == 2 && name[0] == '>') {
123: i--;
124: }
125: if (i == 2) {
126: if (strcmp("-a", option) == 0) {
127: queryType = T_CNAME;
128: } else if (strcmp("-h", option) == 0) {
129: queryType = T_HINFO;
130: } else if (strcmp("-m", option) == 0) {
131: queryType = T_MX;
132: } else {
133: queryType = T_A;
134: }
135: namePtr = name;
136: } else if (i == 1) {
137: namePtr = option;
138: queryType = T_A;
139: } else {
140: fprintf(stderr, "ListHosts: invalid request %s\n",string);
141: return(ERROR);
142: }
143:
144:
145: /*
146: * Create a query packet for the requested domain name.
147: *
148: */
149: msglen = res_mkquery(QUERY, namePtr, C_IN, T_AXFR,
150: (char *)0, 0, (char *)0,
151: (char *) &buf, sizeof(buf));
152: if (msglen < 0) {
153: if (_res.options & RES_DEBUG) {
154: fprintf(stderr, "ListHosts: Res_mkquery failed\n");
155: }
156: return (ERROR);
157: }
158:
159: bzero((char *)&sin, sizeof(sin));
160: sin.sin_family = AF_INET;
161: sin.sin_port = htons(NAMESERVER_PORT);
162:
163: /*
164: * Check to see if we have the address of the server or the
165: * address of a server who knows about this domain.
166: *
167: * For now, just use the first address in the list.
168: */
169:
170: if (defaultPtr->addrList != NULL) {
171: sin.sin_addr = *(struct in_addr *) defaultPtr->addrList[0];
172: } else {
173: sin.sin_addr = *(struct in_addr *)defaultPtr->servers[0]->addrList[0];
174: }
175:
176: /*
177: * Set up a virtual circuit to the server.
178: */
179: if ((sockFD = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
180: perror("ListHosts");
181: return(ERROR);
182: }
183: if (connect(sockFD, &sin, sizeof(sin)) < 0) {
184: perror("ListHosts");
185: (void) close(sockFD);
186: sockFD = -1;
187: return(ERROR);
188: }
189:
190: /*
191: * Send length & message for zone transfer
192: */
193:
194: len = htons(msglen);
195:
196: if (write(sockFD, (char *)&len, sizeof(len)) != sizeof(len) ||
197: write(sockFD, (char *) &buf, msglen) != msglen) {
198: perror("ListHosts");
199: (void) close(sockFD);
200: sockFD = -1;
201: return(ERROR);
202: }
203:
204: fprintf(stdout,"[%s]\n",
205: (defaultPtr->addrList != NULL) ? defaultPtr->name :
206: defaultPtr->servers[0]->name);
207:
208: if (!putToFile) {
209: filePtr = stdout;
210: } else {
211: filePtr = OpenFile(string, file);
212: if (filePtr == NULL) {
213: fprintf(stderr, "*** Can't open %s for writing\n", file);
214: (void) close(sockFD);
215: sockFD = -1;
216: return(ERROR);
217: }
218: fprintf(filePtr, "> %s\n", string);
219: fprintf(filePtr,"[%s]\n",
220: (defaultPtr->addrList != NULL) ? defaultPtr->name :
221: defaultPtr->servers[0]->name);
222: }
223:
224: fprintf(filePtr, "%-30s", "Host or domain name");
225: switch(queryType) {
226: case T_A:
227: fprintf(filePtr, " %-30s\n", "Internet address");
228: break;
229: case T_HINFO:
230: fprintf(filePtr, " %-20s %s\n", "CPU", "OS");
231: break;
232: case T_CNAME:
233: fprintf(filePtr, " %-30s\n", "Alias");
234: break;
235: case T_MX:
236: fprintf(filePtr, " %10s %s\n", "Metric", "Host");
237: }
238:
239:
240: while (1) {
241:
242: /*
243: * Read the length of the response.
244: */
245:
246: cp = (char *) &buf;
247: amtToRead = sizeof(u_short);
248: while(amtToRead > 0 && (numRead = read(sockFD, cp, amtToRead)) > 0){
249: cp += numRead;
250: amtToRead -= numRead;
251: }
252: if (numRead <= 0) {
253: error = ERR_READING_LEN;
254: break;
255: }
256:
257: if ((len = htons(*(u_short *)&buf)) == 0) {
258: break; /* nothing left to read */
259: }
260:
261: /*
262: * Read the response.
263: */
264:
265: amtToRead = len;
266: cp = (char *) &buf;
267: while(amtToRead > 0 && (numRead = read(sockFD, cp, amtToRead)) > 0){
268: cp += numRead;
269: amtToRead -= numRead;
270: }
271: if (numRead <= 0) {
272: error = ERR_READING_MSG;
273: break;
274: }
275:
276: result = PrintListInfo(filePtr, (char *) &buf, cp, queryType);
277: if (result != SUCCESS) {
278: error = ERR_PRINTING;
279: break;
280: }
281:
282: numAnswers++;
283: if (putToFile && ((numAnswers % HASH_SIZE) == 0)) {
284: fprintf(stdout, "#");
285: fflush(stdout);
286: }
287: cp = buf.qb2 + sizeof(HEADER);
288: cp += dn_skip(cp) + QFIXEDSZ;
289: cp += dn_skip(cp);
290: if ((getshort(cp) == T_SOA)) {
291: if (soacnt)
292: break;
293: else
294: soacnt++;
295: }
296: }
297:
298: if (putToFile) {
299: fprintf(stdout, "%sReceived %d record%s.\n",
300: (numAnswers >= HASH_SIZE) ? "\n" : "",
301: numAnswers,
302: (numAnswers > 1) ? "s" : "");
303: }
304:
305: (void) close(sockFD);
306: sockFD = -1;
307: if (putToFile) {
308: fclose(filePtr);
309: filePtr = NULL;
310: }
311:
312: switch (error) {
313: case NO_ERRORS:
314: return (SUCCESS);
315:
316: case ERR_READING_LEN:
317: return(ERROR);
318:
319: case ERR_PRINTING:
320: fprintf(stderr,"*** Error during listing of %s: %s\n",
321: namePtr, DecodeError(result));
322: return(result);
323:
324: case ERR_READING_MSG:
325: headerPtr = (HEADER *) &buf;
326: fprintf(stderr,"ListHosts: error receiving zone transfer:\n");
327: fprintf(stderr,
328: " result: %s, answers = %d, authority = %d, additional = %d\n",
329: rcodes[headerPtr->rcode],
330: ntohs(headerPtr->ancount), ntohs(headerPtr->nscount),
331: ntohs(headerPtr->arcount));
332: return(ERROR);
333: default:
334: return(ERROR);
335: }
336: }
337:
338:
339: /*
340: *******************************************************************************
341: *
342: * PrintListInfo --
343: *
344: * Used by the ListInfo routine to print the answer
345: * received from the name server. Only the desired
346: * information is printed.
347: *
348: * Results:
349: * SUCCESS the answer was printed without a problem.
350: * NO_INFO the answer packet did not contain an answer.
351: * ERROR the answer was malformed.
352: * Misc. errors returned in the packet header.
353: *
354: *******************************************************************************
355: */
356:
357: #define NAME_FORMAT " %-30s"
358: #define STRIP_DOMAIN(string) if((dot = index(string, '.')) != NULL) *dot = '\0'
359:
360:
361: PrintListInfo(file, msg, eom, queryType)
362: FILE *file;
363: char *msg, *eom;
364: int queryType;
365: {
366: register char *cp;
367: HEADER *headerPtr;
368: int type, class, dlen, nameLen;
369: int n;
370: struct in_addr inaddr;
371: char name[NAME_LEN];
372: char name2[NAME_LEN];
373: char *dot;
374:
375: /*
376: * Read the header fields.
377: */
378: headerPtr = (HEADER *)msg;
379: cp = msg + sizeof(HEADER);
380: if (headerPtr->rcode != NOERROR) {
381: return(headerPtr->rcode);
382: }
383:
384: /*
385: * We are looking for info from answer resource records.
386: * If there aren't any, return with an error. We assume
387: * there aren't any question records.
388: */
389:
390: if (ntohs(headerPtr->ancount) == 0) {
391: return(NO_INFO);
392: } else {
393: if ((nameLen = dn_expand(msg, eom, cp, name, sizeof(name))) < 0) {
394: return (ERROR);
395: }
396: cp += nameLen;
397: type = getshort(cp);
398: cp += sizeof(u_short);
399: class = getshort(cp);
400: cp += sizeof(u_short) + sizeof(u_long);
401: dlen = getshort(cp);
402: cp += sizeof(u_short);
403:
404: /*
405: * QueryType is used to specify the type of desired information.
406: * T_A - internet address
407: * T_CNAME - aliases
408: * T_HINFO - cpu, OS type
409: * T_MX - mail routing
410: *
411:
412: */
413: switch (type) {
414:
415: case T_A:
416: if (queryType != T_A)
417: break;
418:
419: if (class == C_IN) {
420: STRIP_DOMAIN(name);
421: fprintf(file, NAME_FORMAT, name);
422: bcopy(cp, (char *)&inaddr, sizeof(inaddr));
423: if (dlen == 4) {
424: fprintf(file," %s\n", inet_ntoa(inaddr));
425: } else if (dlen == 7) {
426: fprintf(file," %s", inet_ntoa(inaddr));
427: fprintf(file," (%d, %d)\n", cp[4],(cp[5] << 8) + cp[6]);
428: }
429: }
430: break;
431:
432: case T_CNAME:
433: if (queryType != T_CNAME)
434: break;
435:
436: STRIP_DOMAIN(name);
437: if ((nameLen = dn_expand(msg, eom, cp, name2, sizeof(name2))) < 0) {
438: return (ERROR);
439: }
440: /*
441: * a bug -- cnames need not be in same domain!
442: * STRIP_DOMAIN(name2);
443: */
444:
445: fprintf(file, NAME_FORMAT, name2);
446: fprintf(file, " %s\n", name);
447: break;
448:
449: case T_HINFO:
450: if (queryType != T_HINFO)
451: break;
452:
453: STRIP_DOMAIN(name);
454: fprintf(file, NAME_FORMAT, name);
455: if (n = *cp++) {
456: sprintf(name,"%.*s", n, cp);
457: fprintf(file," %-20s", name);
458: cp += n;
459: } else {
460: fprintf(file," %-20s", " ");
461: }
462: if (n = *cp++) {
463: fprintf(file," %.*s\n", n, cp);
464: cp += n;
465: }
466: break;
467:
468: case T_MX:
469: if (queryType != T_MX)
470: break;
471:
472: STRIP_DOMAIN(name);
473: fprintf(file, NAME_FORMAT, name);
474:
475: {
476: short pref;
477:
478: pref = getshort(cp);
479: cp += sizeof(u_short);
480: fprintf(file,"%10d",pref);
481: }
482: if ((nameLen = dn_expand(msg, eom, cp, name2, sizeof(name2))) < 0) {
483: return (ERROR);
484: }
485: fprintf(file, " %s\n", name2);
486:
487: break;
488:
489:
490: case T_NS:
491: case T_PTR:
492: if (queryType != T_A)
493: break;
494: /*
495: * Found a name server or pointer record.
496: */
497: fprintf(file, NAME_FORMAT, name);
498: fprintf(file," server = ");
499: cp = Print_cdname2(cp, msg, eom, file);
500: fprintf(file,"\n");
501: break;
502:
503: default:
504: /*
505: * Unwanted answer type -- ignore it.
506: */
507: break;
508: }
509: }
510: return(SUCCESS);
511: }
512:
513:
514: /*
515: *******************************************************************************
516: *
517: * ViewList --
518: *
519: * A hack to view the output of the ls command in sorted
520: * order using more.
521: *
522: *******************************************************************************
523: */
524:
525: ViewList(string)
526: char *string;
527: {
528: char file[NAME_LEN];
529: char command[NAME_LEN];
530:
531: sscanf(string, " view %s", file);
532: sprintf(command, "grep \"^ \" %s | sort | more", file);
533: system(command);
534: }
535:
536: /*
537: *******************************************************************************
538: *
539: * Finger --
540: *
541: * Connects with the finger server for the current host
542: * to request info on the specified person (long form)
543: * who is on the system (short form).
544: *
545: * Results:
546: * SUCCESS the finger server was contacted.
547: * ERROR the server could not be contacted because
548: * a socket could not be obtained or connected
549: * to or the service could not be found.
550: *
551: *******************************************************************************
552: */
553:
554: Finger(string, putToFile)
555: char *string;
556: int putToFile;
557: {
558: struct servent *sp;
559: struct sockaddr_in sin;
560: register FILE *f;
561: register int c;
562: register int lastc;
563: char name[NAME_LEN];
564: char file[NAME_LEN];
565:
566: /*
567: * We need a valid current host info to get an inet address.
568: */
569: if (!curHostValid) {
570: fprintf(stderr, "Finger: no current host defined.\n");
571: return (ERROR);
572: }
573:
574: if (sscanf(string, " finger %s", name) == 1) {
575: if (putToFile && (name[0] == '>')) {
576: name[0] = '\0';
577: }
578: } else {
579: name[0] = '\0';
580: }
581:
582: sp = getservbyname("finger", "tcp");
583: if (sp == 0) {
584: fprintf(stderr, "Finger: unknown service\n");
585: return (ERROR);
586: }
587:
588: bzero((char *)&sin, sizeof(sin));
589: sin.sin_family = curHostInfo.addrType;
590: sin.sin_port = sp->s_port;
591: bcopy(curHostInfo.addrList[0], (char *)&sin.sin_addr,
592: curHostInfo.addrLen);
593:
594: /*
595: * Set up a virtual circuit to the host.
596: */
597:
598: sockFD = socket(curHostInfo.addrType, SOCK_STREAM, 0);
599: if (sockFD < 0) {
600: fflush(stdout);
601: perror("Finger");
602: return (ERROR);
603: }
604:
605: if (connect(sockFD, (char *)&sin, sizeof (sin)) < 0) {
606: fflush(stdout);
607: perror("Finger");
608: close(sockFD);
609: sockFD = -1;
610: return (ERROR);
611: }
612:
613: if (!putToFile) {
614: filePtr = stdout;
615: } else {
616: filePtr = OpenFile(string, file);
617: if (filePtr == NULL) {
618: fprintf(stderr, "*** Can't open %s for writing\n", file);
619: close(sockFD);
620: sockFD = -1;
621: return(ERROR);
622: }
623: fprintf(filePtr,"> %s\n", string);
624: }
625: fprintf(filePtr, "[%s]\n", curHostInfo.name);
626:
627: if (name[0] != '\0') {
628: write(sockFD, "/W ", 3);
629: }
630: write(sockFD, name, strlen(name));
631: write(sockFD, "\r\n", 2);
632: f = fdopen(sockFD, "r");
633: while ((c = getc(f)) != EOF) {
634: switch(c) {
635: case 0210:
636: case 0211:
637: case 0212:
638: case 0214:
639: c -= 0200;
640: break;
641: case 0215:
642: c = '\n';
643: break;
644: }
645: putc(lastc = c, filePtr);
646: }
647: if (lastc != '\n') {
648: putc('\n', filePtr);
649: }
650: putc('\n', filePtr);
651:
652: close(sockFD);
653: sockFD = -1;
654:
655: if (putToFile) {
656: fclose(filePtr);
657: filePtr = NULL;
658: }
659: return (SUCCESS);
660: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.