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