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