![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named / tools / nslookup|
Return to subr.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named / tools / nslookup |
1.1 root 1: /*
2: * Copyright (c) 1985 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that this notice is preserved and that due credit is given
7: * to the University of California at Berkeley. The name of the University
8: * may not be used to endorse or promote products derived from this
9: * software without specific prior written permission. This software
10: * is provided ``as is'' without express or implied warranty.
11: */
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)subr.c 5.9 (Berkeley) 2/17/88";
15: #endif /* not lint */
16:
17: /*
18: *******************************************************************************
19: *
20: * subr.c --
21: *
22: * Miscellaneous subroutines for the name server
23: * lookup program.
24: *
25: * Copyright (c) 1985
26: * Andrew Cherenson
27: * CS298-26 Fall 1985
28: *
29: *******************************************************************************
30: */
31:
32: #include <stdio.h>
33: #include <strings.h>
34: #include <sys/types.h>
35: #include <netdb.h>
36: #include <sys/socket.h>
37: #include <netinet/in.h>
38: #include <arpa/nameser.h>
39: #include <signal.h>
40: #include <setjmp.h>
41: #include "res.h"
42:
43:
44:
45: /*
46: *******************************************************************************
47: *
48: * IntrHandler --
49: *
50: * This routine is called whenever a control-C is typed.
51: * It performs three main functions:
52: * - close an open socket connection.
53: * - close an open output file (used by LookupHost, et al.)
54: * - jump back to the main read-eval loop.
55: *
56: * Since a user may type a ^C in the middle of a routine that
57: * is using a socket, the socket would never get closed by the
58: * routine. To prevent an overflow of the process's open file table,
59: * the socket and output file descriptors are closed by
60: * the interrupt handler.
61: *
62: * Side effects:
63: * If sockFD is valid, its socket is closed.
64: * If filePtr is valid, its file is closed.
65: * Flow of control returns to the main() routine.
66: *
67: *******************************************************************************
68: */
69:
70: int
71: IntrHandler()
72: {
73: extern jmp_buf env;
74:
75: if (sockFD >= 0) {
76: close(sockFD);
77: sockFD = -1;
78: }
79: if (filePtr != NULL && filePtr != stdout) {
80: fclose(filePtr);
81: filePtr = NULL;
82: }
83: printf("\n");
84: longjmp(env, 1);
85: }
86:
87:
88: /*
89: *******************************************************************************
90: *
91: * Calloc --
92: *
93: * Calls the calloc library routine with the interrupt
94: * signal blocked. The interrupt signal blocking is done
95: * to prevent malloc from getting confused if a
96: * control-C arrives in the middle of its bookkeeping
97: * routines. We need to do this because a control-C
98: * causes a return to the main command loop instead
99: * causing the program to die.
100: *
101: * This method doesn't prevent the pointer returned
102: * by calloc from getting lost, so it is possible
103: * to get "core leaks".
104: *
105: * Results:
106: * (address) - address of new buffer.
107: * NULL - calloc failed.
108: *
109: *******************************************************************************
110: */
111:
112: char *
113: Calloc(num, size)
114: unsigned num, size;
115: {
116: char *ptr;
117: int saveMask;
118: extern char *calloc();
119:
120: saveMask = sigblock(1 << (SIGINT-1));
121: ptr = calloc(num, size);
122: (void) sigsetmask(saveMask);
123: if (ptr == NULL) {
124: fflush(stdout);
125: fprintf(stderr, "Calloc failed\n");
126: fflush(stderr);
127: abort();
128: /*NOTREACHED*/
129: } else {
130: return(ptr);
131: }
132: }
133:
134: /*
135: *******************************************************************************
136: *
137: * PrintHostInfo --
138: *
139: * Prints out the HostInfo structure for a host.
140: *
141: *******************************************************************************
142: */
143:
144: void
145: PrintHostInfo(file, title, hp)
146: FILE *file;
147: char *title;
148: register HostInfo *hp;
149: {
150: register char **cp;
151: register ServerInfo **sp;
152: char comma;
153: int i;
154:
155: fprintf(file, "%-7s %s\n", title, hp->name);
156:
157: if (hp->addrList != NULL) {
158: if (hp->addrList[1] != NULL) {
159: fprintf(file, "Addresses:");
160: } else {
161: fprintf(file, "Address:");
162: }
163: comma = ' ';
164: i = 0;
165: for (cp = hp->addrList; cp && *cp; cp++) {
166: i++;
167: if (i > 4) {
168: fprintf(file, "\n\t");
169: comma = ' ';
170: i = 0;
171: }
172: fprintf(file,"%c %s", comma, inet_ntoa(*(struct in_addr *)*cp));
173: comma = ',';
174: }
175: }
176:
177: if (hp->aliases != NULL) {
178: fprintf(file, "\nAliases:");
179: comma = ' ';
180: i = 10;
181: for (cp = hp->aliases; cp && *cp && **cp; cp++) {
182: i += strlen(*cp) + 2;
183: if (i > 75) {
184: fprintf(file, "\n\t");
185: comma = ' ';
186: i = 10;
187: }
188: fprintf(file, "%c %s", comma, *cp);
189: comma = ',';
190: }
191: }
192:
193: if (hp->servers != NULL) {
194: fprintf(file, "Served by:\n");
195: for (sp = hp->servers; *sp != NULL ; sp++) {
196:
197: fprintf(file, "- %s\n\t", (*sp)->name);
198:
199: comma = ' ';
200: i = 0;
201: for (cp = (*sp)->addrList; cp && *cp && **cp; cp++) {
202: i++;
203: if (i > 4) {
204: fprintf(file, "\n\t");
205: comma = ' ';
206: i = 0;
207: }
208: fprintf(file,
209: "%c %s", comma, inet_ntoa(*(struct in_addr *)*cp));
210: comma = ',';
211: }
212: fprintf(file, "\n\t");
213:
214: comma = ' ';
215: i = 10;
216: for (cp = (*sp)->domains; cp && *cp && **cp; cp++) {
217: i += strlen(*cp) + 2;
218: if (i > 75) {
219: fprintf(file, "\n\t");
220: comma = ' ';
221: i = 10;
222: }
223: fprintf(file, "%c %s", comma, *cp);
224: comma = ',';
225: }
226: fprintf(file, "\n");
227: }
228: }
229:
230: fprintf(file, "\n\n");
231: }
232:
233: /*
234: *******************************************************************************
235: *
236: * OpenFile --
237: *
238: * Parses a command string for a file name and opens
239: * the file.
240: *
241: * Results:
242: * file pointer - the open was successful.
243: * NULL - there was an error opening the file or
244: * the input string was invalid.
245: *
246: *******************************************************************************
247: */
248:
249: FILE *
250: OpenFile(string, file)
251: char *string;
252: char *file;
253: {
254: char *redirect;
255: FILE *tmpPtr;
256:
257: /*
258: * Open an output file if we see '>' or >>'.
259: * Check for overwrite (">") or concatenation (">>").
260: */
261:
262: redirect = index(string, '>');
263: if (redirect == NULL) {
264: return(NULL);
265: }
266: if (redirect[1] == '>') {
267: sscanf(redirect, ">> %s", file);
268: tmpPtr = fopen(file, "a+");
269: } else {
270: sscanf(redirect, "> %s", file);
271: tmpPtr = fopen(file, "w");
272: }
273:
274: if (tmpPtr != NULL) {
275: redirect[0] = '\0';
276: }
277:
278: return(tmpPtr);
279: }
280:
281: /*
282: *******************************************************************************
283: *
284: * DecodeError --
285: *
286: * Converts an error code into a character string.
287: *
288: *******************************************************************************
289: */
290:
291: char *
292: DecodeError(result)
293: int result;
294: {
295: switch(result) {
296: case NOERROR: return("Success"); break;
297: case FORMERR: return("Format error"); break;
298: case SERVFAIL: return("Server failed"); break;
299: case NXDOMAIN: return("Non-existent domain"); break;
300: case NOTIMP: return("Not implemented"); break;
301: case REFUSED: return("Query refused"); break;
302: case NOCHANGE: return("No change"); break;
303: case NO_INFO: return("No information"); break;
304: case ERROR: return("Unspecified error"); break;
305: case TIME_OUT: return("Timed out"); break;
306: case NONAUTH: return("Non-authoritative answer"); break;
307: default: break;
308: }
309: return("BAD ERROR VALUE");
310: }
311:
312: int
313: StringToClass(class, dflt)
314: char *class;
315: int dflt;
316: {
317: if (strcasecmp(class, "IN") == 0)
318: return(C_IN);
319: if (strcasecmp(class, "CHAOS") == 0)
320: return(C_CHAOS);
321: if (strcasecmp(class, "ANY") == 0)
322: return(C_ANY);
323: fprintf(stderr, "unknown query class: %s\n", class);
324: return(dflt);
325: }
326: /*
327: *******************************************************************************
328: *
329: * StringToType --
330: *
331: * Converts a string form of a query type name to its
332: * corresponding integer value.
333: *
334: *******************************************************************************
335: */
336:
337: int
338: StringToType(type, dflt)
339: char *type;
340: int dflt;
341: {
342: if (strcasecmp(type, "A") == 0)
343: return(T_A);
344: if (strcasecmp(type, "NS") == 0)
345: return(T_NS); /* authoritative server */
346: if (strcasecmp(type, "MX") == 0)
347: return(T_MX); /* mail exchanger */
348: if (strcasecmp(type, "CNAME") == 0)
349: return(T_CNAME); /* canonical name */
350: if (strcasecmp(type, "SOA") == 0)
351: return(T_SOA); /* start of authority zone */
352: if (strcasecmp(type, "MB") == 0)
353: return(T_MB); /* mailbox domain name */
354: if (strcasecmp(type, "MG") == 0)
355: return(T_MG); /* mail group member */
356: if (strcasecmp(type, "MR") == 0)
357: return(T_MR); /* mail rename name */
358: if (strcasecmp(type, "WKS") == 0)
359: return(T_WKS); /* well known service */
360: if (strcasecmp(type, "PTR") == 0)
361: return(T_PTR); /* domain name pointer */
362: if (strcasecmp(type, "HINFO") == 0)
363: return(T_HINFO); /* host information */
364: if (strcasecmp(type, "MINFO") == 0)
365: return(T_MINFO); /* mailbox information */
366: if (strcasecmp(type, "AXFR") == 0)
367: return(T_AXFR); /* zone transfer */
368: if (strcasecmp(type, "MAILB") == 0)
369: return(T_MAILB); /* mail box */
370: if (strcasecmp(type, "ANY") == 0)
371: return(T_ANY); /* matches any type */
372: if (strcasecmp(type, "UINFO") == 0)
373: return(T_UINFO); /* user info */
374: if (strcasecmp(type, "UID") == 0)
375: return(T_UID); /* user id */
376: if (strcasecmp(type, "GID") == 0)
377: return(T_GID); /* group id */
378: fprintf(stderr, "unknown query type: %s\n", type);
379: return(dflt);
380: }
381:
382: /*
383: *******************************************************************************
384: *
385: * DecodeType --
386: *
387: * Converts a query type to a descriptive name.
388: * (A more verbose form of p_type.)
389: *
390: *
391: *******************************************************************************
392: */
393:
394: static char nbuf[20];
395:
396: char *
397: DecodeType(type)
398: int type;
399: {
400: switch (type) {
401: case T_A:
402: return("address");
403: case T_NS:
404: return("name server");
405: case T_MX:
406: return("mail exchanger");
407: case T_CNAME:
408: return("cannonical name");
409: case T_SOA:
410: return("start of authority zone");
411: case T_MB:
412: return("mailbox domain name");
413: case T_MG:
414: return("mail group member");
415: case T_MR:
416: return("mail rename name");
417: case T_NULL:
418: return("null resource record");
419: case T_WKS:
420: return("well known service");
421: case T_PTR:
422: return("domain name pointer");
423: case T_HINFO:
424: return("host");
425: case T_MINFO:
426: return("mailbox (MINFO)");
427: case T_AXFR:
428: return("zone transfer");
429: case T_MAILB:
430: return("mail box");
431: case T_ANY:
432: return("any type");
433: case T_UINFO:
434: return("user info");
435: case T_UID:
436: return("user id");
437: case T_GID:
438: return("group id");
439: default:
440: (void) sprintf(nbuf, "%d", type);
441: return (nbuf);
442: }
443: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.