![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.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 main.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: char copyright[] =
22: "@(#) Copyright (c) 1985,1989 Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)main.c 5.39 (Berkeley) 6/24/90";
28: #endif /* not lint */
29:
30: /*
31: *******************************************************************************
32: *
33: * main.c --
34: *
35: * Main routine and some action routines for the name server
36: * lookup program.
37: *
38: * Andrew Cherenson
39: * U.C. Berkeley Computer Science Div.
40: * CS298-26, Fall 1985
41: *
42: *******************************************************************************
43: */
44:
45: #include <sys/param.h>
46: #include <netdb.h>
47: #include <sys/socket.h>
48: #include <netinet/in.h>
49: #include <arpa/nameser.h>
50: #include <arpa/inet.h>
51: #include <resolv.h>
52: #include <signal.h>
53: #include <setjmp.h>
54: #include <ctype.h>
55: #include <stdio.h>
56: #include <stdlib.h>
57: #include <string.h>
58: #include "res.h"
59: #include "pathnames.h"
60:
61: /*
62: * Default Internet address of the current host.
63: */
64:
65: #if BSD < 43
66: #define LOCALHOST "127.0.0.1"
67: #endif
68:
69:
70: /*
71: * Name of a top-level name server. Can be changed with
72: * the "set root" command.
73: */
74:
75: #ifndef ROOT_SERVER
76: #define ROOT_SERVER "ns.nic.ddn.mil."
77: #endif
78: char rootServerName[NAME_LEN] = ROOT_SERVER;
79:
80:
81: /*
82: * Import the state information from the resolver library.
83: */
84:
85: extern struct state _res;
86:
87:
88: /*
89: * Info about the most recently queried host.
90: */
91:
92: HostInfo curHostInfo;
93: int curHostValid = FALSE;
94:
95:
96: /*
97: * Info about the default name server.
98: */
99:
100: HostInfo *defaultPtr = NULL;
101: char defaultServer[NAME_LEN];
102: struct in_addr defaultAddr;
103:
104:
105: /*
106: * Initial name server query type is Address.
107: */
108:
109: int queryType = T_A;
110: int queryClass = C_IN;
111:
112: /*
113: * Stuff for Interrupt (control-C) signal handler.
114: */
115:
116: #ifdef SVR3
117: extern void IntrHandler();
118: #else
119: extern int IntrHandler();
120: #endif
121: FILE *filePtr;
122: jmp_buf env;
123:
124: static void CvtAddrToPtr();
125: static void ReadRC();
126:
127:
128: /*
129: *******************************************************************************
130: *
131: * main --
132: *
133: * Initializes the resolver library and determines the address
134: * of the initial name server. The yylex routine is used to
135: * read and perform commands.
136: *
137: *******************************************************************************
138: */
139:
140: main(argc, argv)
141: int argc;
142: char **argv;
143: {
144: char *wantedHost = NULL;
145: Boolean useLocalServer;
146: int result;
147: int i;
148: struct hostent *hp;
149: extern int h_errno;
150:
151: /*
152: * Initialize the resolver library routines.
153: */
154:
155: if (res_init() == -1) {
156: fprintf(stderr,"*** Can't initialize resolver.\n");
157: exit(1);
158: }
159:
160: /*
161: * Allocate space for the default server's host info and
162: * find the server's address and name. If the resolver library
163: * already has some addresses for a potential name server,
164: * then use them. Otherwise, see if the current host has a server.
165: * Command line arguments may override the choice of initial server.
166: */
167:
168: defaultPtr = (HostInfo *) Calloc(1, sizeof(HostInfo));
169:
170: /*
171: * Parse the arguments:
172: * no args = go into interactive mode, use default host as server
173: * 1 arg = use as host name to be looked up, default host will be server
174: * non-interactive mode
175: * 2 args = 1st arg:
176: * if it is '-', then
177: * ignore but go into interactive mode
178: * else
179: * use as host name to be looked up,
180: * go into non-interactive mode
181: * 2nd arg: name or inet address of server
182: *
183: * "Set" options are specified with a leading - and must come before
184: * any arguments. For example, to find the well-known services for
185: * a host, type "nslookup -query=wks host"
186: */
187:
188: ReadRC(); /* look for options file */
189:
190: ++argv; --argc; /* skip prog name */
191:
192: while (argc && *argv[0] == '-' && argv[0][1]) {
193: (void) SetOption (&(argv[0][1]));
194: ++argv; --argc;
195: }
196: if (argc > 2) {
197: Usage();
198: }
199: if (argc && *argv[0] != '-') {
200: wantedHost = *argv; /* name of host to be looked up */
201: }
202:
203: useLocalServer = FALSE;
204: if (argc == 2) {
205: struct in_addr addr;
206:
207: /*
208: * Use an explicit name server. If the hostname lookup fails,
209: * default to the server(s) in resolv.conf.
210: */
211:
212: addr.s_addr = inet_addr(*++argv);
213: if (addr.s_addr != (unsigned long)-1) {
214: _res.nscount = 1;
215: _res.nsaddr.sin_addr = addr;
216: } else {
217: hp = gethostbyname(*argv);
218: if (hp == NULL) {
219: fprintf(stderr, "*** Can't find server address for '%s': ",
220: *argv);
221: herror((char *)NULL);
222: fputc('\n', stderr);
223: } else {
224: #if BSD < 43
225: bcopy(hp->h_addr, (char *)&_res.nsaddr.sin_addr, hp->h_length);
226: _res.nscount = 1;
227: #else
228: for (i = 0; i < MAXNS && hp->h_addr_list[i] != NULL; i++) {
229: bcopy(hp->h_addr_list[i],
230: (char *)&_res.nsaddr_list[i].sin_addr,
231: hp->h_length);
232: }
233: _res.nscount = i;
234: #endif
235: }
236: }
237: }
238:
239:
240: if (_res.nscount == 0 || useLocalServer) {
241: LocalServer(defaultPtr);
242: } else {
243: for (i = 0; i < _res.nscount; i++) {
244: if (_res.nsaddr_list[i].sin_addr.s_addr == INADDR_ANY) {
245: LocalServer(defaultPtr);
246: break;
247: } else {
248: result = GetHostInfoByAddr(&(_res.nsaddr_list[i].sin_addr),
249: &(_res.nsaddr_list[i].sin_addr),
250: defaultPtr);
251: if (result != SUCCESS) {
252: fprintf(stderr,
253: "*** Can't find server name for address %s: %s\n",
254: inet_ntoa(_res.nsaddr_list[i].sin_addr),
255: DecodeError(result));
256: } else {
257: defaultAddr = _res.nsaddr_list[i].sin_addr;
258: break;
259: }
260: }
261: }
262:
263: /*
264: * If we have exhausted the list, tell the user about the
265: * command line argument to specify an address.
266: */
267:
268: if (i == _res.nscount) {
269: fprintf(stderr, "*** Default servers are not available\n");
270: exit(1);
271: }
272:
273: }
274: strcpy(defaultServer, defaultPtr->name);
275:
276:
277: #ifdef DEBUG
278: #ifdef DEBUG2
279: _res.options |= RES_DEBUG2;
280: #endif
281: _res.options |= RES_DEBUG;
282: _res.retry = 2;
283: #endif DEBUG
284:
285: /*
286: * If we're in non-interactive mode, look up the wanted host and quit.
287: * Otherwise, print the initial server's name and continue with
288: * the initialization.
289: */
290:
291: if (wantedHost != (char *) NULL) {
292: LookupHost(wantedHost, 0);
293: } else {
294: PrintHostInfo(stdout, "Default Server:", defaultPtr);
295:
296: /*
297: * Setup the environment to allow the interrupt handler to return here.
298: */
299:
300: (void) setjmp(env);
301:
302: /*
303: * Return here after a longjmp.
304: */
305:
306: signal(SIGINT, IntrHandler);
307: signal(SIGPIPE, SIG_IGN);
308:
309: /*
310: * Read and evaluate commands. The commands are described in commands.l
311: * Yylex returns 0 when ^D or 'exit' is typed.
312: */
313:
314: printf("> ");
315: fflush(stdout);
316: while(yylex()) {
317: printf("> ");
318: fflush(stdout);
319: }
320: }
321: exit(0);
322: }
323:
324:
325: LocalServer(defaultPtr)
326: HostInfo *defaultPtr;
327: {
328: char hostName[NAME_LEN];
329: #if BSD < 43
330: int result;
331: #endif
332:
333: gethostname(hostName, sizeof(hostName));
334:
335: #if BSD < 43
336: defaultAddr.s_addr = inet_addr(LOCALHOST);
337: result = GetHostInfoByName(&defaultAddr, C_IN, T_A,
338: hostName, defaultPtr, 1);
339: if (result != SUCCESS) {
340: fprintf(stderr,
341: "*** Can't find initialize address for server %s: %s\n",
342: defaultServer, DecodeError(result));
343: exit(1);
344: }
345: #else
346: defaultAddr.s_addr = htonl(INADDR_ANY);
347: (void) GetHostInfoByName(&defaultAddr, C_IN, T_A, "0.0.0.0", defaultPtr, 1);
348: free(defaultPtr->name);
349: defaultPtr->name = Calloc(1, sizeof(hostName)+1);
350: strcpy(defaultPtr->name, hostName);
351: #endif
352: }
353:
354:
355: /*
356: *******************************************************************************
357: *
358: * Usage --
359: *
360: * Lists the proper methods to run the program and exits.
361: *
362: *******************************************************************************
363: */
364:
365: Usage()
366: {
367: fprintf(stderr, "Usage:\n");
368: fprintf(stderr,
369: " nslookup [-opt ...] # interactive mode using default server\n");
370: fprintf(stderr,
371: " nslookup [-opt ...] - server # interactive mode using 'server'\n");
372: fprintf(stderr,
373: " nslookup [-opt ...] host # just look up 'host' using default server\n");
374: fprintf(stderr,
375: " nslookup [-opt ...] host server # just look up 'host' using 'server'\n");
376: exit(1);
377: }
378:
379: /*
380: *******************************************************************************
381: *
382: * IsAddr --
383: *
384: * Returns TRUE if the string looks like an Internet address.
385: * A string with a trailing dot is not an address, even if it looks
386: * like one.
387: *
388: * XXX doesn't treat 255.255.255.255 as an address.
389: *
390: *******************************************************************************
391: */
392:
393: Boolean
394: IsAddr(host, addrPtr)
395: char *host;
396: unsigned long *addrPtr; /* If return TRUE, contains IP address */
397: {
398: register char *cp;
399: unsigned long addr;
400:
401: if (isdigit(host[0])) {
402: /* Make sure it has only digits and dots. */
403: for (cp = host; *cp; ++cp) {
404: if (!isdigit(*cp) && *cp != '.')
405: return FALSE;
406: }
407: /* If it has a trailing dot, don't treat it as an address. */
408: if (*--cp != '.') {
409: if ((addr = inet_addr(host)) != (unsigned long) -1) {
410: *addrPtr = addr;
411: return TRUE;
412: #if 0
413: } else {
414: /* XXX Check for 255.255.255.255 case */
415: #endif
416: }
417: }
418: }
419: return FALSE;
420: }
421:
422:
423: /*
424: *******************************************************************************
425: *
426: * SetDefaultServer --
427: *
428: * Changes the default name server to the one specified by
429: * the first argument. The command "server name" uses the current
430: * default server to lookup the info for "name". The command
431: * "lserver name" uses the original server to lookup "name".
432: *
433: * Side effects:
434: * This routine will cause a core dump if the allocation requests fail.
435: *
436: * Results:
437: * SUCCESS The default server was changed successfully.
438: * NONAUTH The server was changed but addresses of
439: * other servers who know about the requested server
440: * were returned.
441: * Errors No info about the new server was found or
442: * requests to the current server timed-out.
443: *
444: *******************************************************************************
445: */
446:
447: int
448: SetDefaultServer(string, local)
449: char *string;
450: Boolean local;
451: {
452: register HostInfo *newDefPtr;
453: struct in_addr *servAddrPtr;
454: struct in_addr addr;
455: char newServer[NAME_LEN];
456: int result;
457: int i;
458:
459: /*
460: * Parse the command line. It maybe of the form "server name",
461: * "lserver name" or just "name".
462: */
463:
464: if (local) {
465: i = sscanf(string, " lserver %s", newServer);
466: } else {
467: i = sscanf(string, " server %s", newServer);
468: }
469: if (i != 1) {
470: i = sscanf(string, " %s", newServer);
471: if (i != 1) {
472: fprintf(stderr,"SetDefaultServer: invalid name: %s\n", string);
473: return(ERROR);
474: }
475: }
476:
477: /*
478: * Allocate space for a HostInfo variable for the new server. Don't
479: * overwrite the old HostInfo struct because info about the new server
480: * might not be found and we need to have valid default server info.
481: */
482:
483: newDefPtr = (HostInfo *) Calloc(1, sizeof(HostInfo));
484:
485:
486: /*
487: * A 'local' lookup uses the original server that the program was
488: * initialized with.
489: *
490: * Check to see if we have the address of the server or the
491: * address of a server who knows about this domain.
492: * XXX For now, just use the first address in the list.
493: */
494:
495: if (local) {
496: servAddrPtr = &defaultAddr;
497: } else if (defaultPtr->addrList != NULL) {
498: servAddrPtr = (struct in_addr *) defaultPtr->addrList[0];
499: } else {
500: servAddrPtr = (struct in_addr *) defaultPtr->servers[0]->addrList[0];
501: }
502:
503: result = ERROR;
504: if (IsAddr(newServer, &addr.s_addr)) {
505: result = GetHostInfoByAddr(servAddrPtr, &addr, newDefPtr);
506: /* If we can't get the name, fall through... */
507: }
508: if (result != SUCCESS && result != NONAUTH) {
509: result = GetHostInfoByName(servAddrPtr, C_IN, T_A,
510: newServer, newDefPtr, 1);
511: }
512:
513: if (result == SUCCESS || result == NONAUTH) {
514: /*
515: * Found info about the new server. Free the resources for
516: * the old server.
517: */
518:
519: FreeHostInfoPtr(defaultPtr);
520: free((char *)defaultPtr);
521: defaultPtr = newDefPtr;
522: strcpy(defaultServer, defaultPtr->name);
523: PrintHostInfo(stdout, "Default Server:", defaultPtr);
524: return(SUCCESS);
525: } else {
526: fprintf(stderr, "*** Can't find address for server %s: %s\n",
527: newServer, DecodeError(result));
528: free((char *)newDefPtr);
529:
530: return(result);
531: }
532: }
533:
534: /*
535: *******************************************************************************
536: *
537: * DoLoookup --
538: *
539: * Common subroutine for LookupHost and LookupHostWithServer.
540: *
541: * Results:
542: * SUCCESS - the lookup was successful.
543: * Misc. Errors - an error message is printed if the lookup failed.
544: *
545: *******************************************************************************
546: */
547:
548: static int
549: DoLookup(host, servPtr, serverName)
550: char *host;
551: HostInfo *servPtr;
552: char *serverName;
553: {
554: int result;
555: struct in_addr *servAddrPtr;
556: struct in_addr addr;
557:
558: /* Skip escape character */
559: if (host[0] == '\\')
560: host++;
561:
562: /*
563: * If the user gives us an address for an address query,
564: * silently treat it as a PTR query. If the query type is already
565: * PTR, then convert the address into the in-addr.arpa format.
566: *
567: * Use the address of the server if it exists, otherwise use the
568: * address of a server who knows about this domain.
569: * XXX For now, just use the first address in the list.
570: */
571:
572: if (servPtr->addrList != NULL) {
573: servAddrPtr = (struct in_addr *) servPtr->addrList[0];
574: } else {
575: servAddrPtr = (struct in_addr *) servPtr->servers[0]->addrList[0];
576: }
577:
578: /*
579: * RFC1123 says we "SHOULD check the string syntactically for a
580: * dotted-decimal number before looking it up [...]" (p. 13).
581: */
582: if (queryType == T_A && IsAddr(host, &addr.s_addr)) {
583: result = GetHostInfoByAddr(servAddrPtr, &addr, &curHostInfo);
584: } else {
585: if (queryType == T_PTR) {
586: CvtAddrToPtr(host);
587: }
588: result = GetHostInfoByName(servAddrPtr, queryClass, queryType, host,
589: &curHostInfo, 0);
590: }
591:
592: switch (result) {
593: case SUCCESS:
594: /*
595: * If the query was for an address, then the &curHostInfo
596: * variable can be used by Finger.
597: * There's no need to print anything for other query types
598: * because the info has already been printed.
599: */
600: if (queryType == T_A) {
601: curHostValid = TRUE;
602: PrintHostInfo(filePtr, "Name:", &curHostInfo);
603: }
604: break;
605:
606: /*
607: * No Authoritative answer was available but we got names
608: * of servers who know about the host.
609: */
610: case NONAUTH:
611: PrintHostInfo(filePtr, "Name:", &curHostInfo);
612: break;
613:
614: case NO_INFO:
615: fprintf(stderr, "*** No %s (%s) records available for %s\n",
616: DecodeType(queryType), p_type(queryType), host);
617: break;
618:
619: case TIME_OUT:
620: fprintf(stderr, "*** Request to %s timed-out\n", serverName);
621: break;
622:
623: default:
624: fprintf(stderr, "*** %s can't find %s: %s\n", serverName, host,
625: DecodeError(result));
626: }
627: return result;
628: }
629:
630: /*
631: *******************************************************************************
632: *
633: * LookupHost --
634: *
635: * Asks the default name server for information about the
636: * specified host or domain. The information is printed
637: * if the lookup was successful.
638: *
639: * Results:
640: * ERROR - the output file could not be opened.
641: * + results of DoLookup
642: *
643: *******************************************************************************
644: */
645:
646: int
647: LookupHost(string, putToFile)
648: char *string;
649: Boolean putToFile;
650: {
651: char host[NAME_LEN];
652: char file[NAME_LEN];
653: int result;
654:
655: /*
656: * Invalidate the current host information to prevent Finger
657: * from using bogus info.
658: */
659:
660: curHostValid = FALSE;
661:
662: /*
663: * Parse the command string into the host and
664: * optional output file name.
665: *
666: */
667:
668: sscanf(string, " %s", host); /* removes white space */
669: if (!putToFile) {
670: filePtr = stdout;
671: } else {
672: filePtr = OpenFile(string, file);
673: if (filePtr == NULL) {
674: fprintf(stderr, "*** Can't open %s for writing\n", file);
675: return(ERROR);
676: }
677: fprintf(filePtr,"> %s\n", string);
678: }
679:
680: PrintHostInfo(filePtr, "Server:", defaultPtr);
681:
682: result = DoLookup(host, defaultPtr, defaultServer);
683:
684: if (putToFile) {
685: fclose(filePtr);
686: filePtr = NULL;
687: }
688: return(result);
689: }
690:
691: /*
692: *******************************************************************************
693: *
694: * LookupHostWithServer --
695: *
696: * Asks the name server specified in the second argument for
697: * information about the host or domain specified in the first
698: * argument. The information is printed if the lookup was successful.
699: *
700: * Address info about the requested name server is obtained
701: * from the default name server. This routine will return an
702: * error if the default server doesn't have info about the
703: * requested server. Thus an error return status might not
704: * mean the requested name server doesn't have info about the
705: * requested host.
706: *
707: * Comments from LookupHost apply here, too.
708: *
709: * Results:
710: * ERROR - the output file could not be opened.
711: * + results of DoLookup
712: *
713: *******************************************************************************
714: */
715:
716: int
717: LookupHostWithServer(string, putToFile)
718: char *string;
719: Boolean putToFile;
720: {
721: char file[NAME_LEN];
722: char host[NAME_LEN];
723: char server[NAME_LEN];
724: int result;
725: static HostInfo serverInfo;
726:
727: curHostValid = FALSE;
728:
729: sscanf(string, " %s %s", host, server);
730: if (!putToFile) {
731: filePtr = stdout;
732: } else {
733: filePtr = OpenFile(string, file);
734: if (filePtr == NULL) {
735: fprintf(stderr, "*** Can't open %s for writing\n", file);
736: return(ERROR);
737: }
738: fprintf(filePtr,"> %s\n", string);
739: }
740:
741: result = GetHostInfoByName(
742: defaultPtr->addrList ?
743: (struct in_addr *) defaultPtr->addrList[0] :
744: (struct in_addr *) defaultPtr->servers[0]->addrList[0],
745: C_IN, T_A, server, &serverInfo, 1);
746:
747: if (result != SUCCESS) {
748: fprintf(stderr,"*** Can't find address for server %s: %s\n", server,
749: DecodeError(result));
750: } else {
751: PrintHostInfo(filePtr, "Server:", &serverInfo);
752:
753: result = DoLookup(host, &serverInfo, server);
754: }
755: if (putToFile) {
756: fclose(filePtr);
757: filePtr = NULL;
758: }
759: return(result);
760: }
761:
762: /*
763: *******************************************************************************
764: *
765: * SetOption --
766: *
767: * This routine is used to change the state information
768: * that affect the lookups. The command format is
769: * set keyword[=value]
770: * Most keywords can be abbreviated. Parsing is very simplistic--
771: * A value must not be separated from its keyword by white space.
772: *
773: * Valid keywords: Meaning:
774: * all lists current values of options.
775: * ALL lists current values of options, including
776: * hidden options.
777: * [no]d2 turn on/off extra debugging mode.
778: * [no]debug turn on/off debugging mode.
779: * [no]defname use/don't use default domain name.
780: * [no]search use/don't use domain search list.
781: * domain=NAME set default domain name to NAME.
782: * [no]ignore ignore/don't ignore trunc. errors.
783: * query=value set default query type to value,
784: * value is one of the query types in RFC883
785: * without the leading T_. (e.g., A, HINFO)
786: * [no]recurse use/don't use recursive lookup.
787: * retry=# set number of retries to #.
788: * root=NAME change root server to NAME.
789: * time=# set timeout length to #.
790: * [no]vc use/don't use virtual circuit.
791: * port TCP/UDP port to server.
792: *
793: * Deprecated:
794: * [no]primary use/don't use primary server.
795: *
796: * Results:
797: * SUCCESS the command was parsed correctly.
798: * ERROR the command was not parsed correctly.
799: *
800: *******************************************************************************
801: */
802:
803: int
804: SetOption(option)
805: register char *option;
806: {
807: char type[NAME_LEN];
808: char *ptr;
809: int tmp;
810:
811: while (isspace(*option))
812: ++option;
813: if (strncmp (option, "set ", 4) == 0)
814: option += 4;
815: while (isspace(*option))
816: ++option;
817:
818: if (*option == 0) {
819: fprintf(stderr, "*** Invalid set command\n");
820: return(ERROR);
821: } else {
822: if (strncmp(option, "all", 3) == 0) {
823: ShowOptions();
824: } else if (strncmp(option, "ALL", 3) == 0) {
825: ShowOptions();
826: } else if (strncmp(option, "d2", 2) == 0) { /* d2 (more debug) */
827: _res.options |= (RES_DEBUG | RES_DEBUG2);
828: } else if (strncmp(option, "nod2", 4) == 0) {
829: _res.options &= ~RES_DEBUG2;
830: printf("d2 mode disabled; still in debug mode\n");
831: } else if (strncmp(option, "def", 3) == 0) { /* defname */
832: _res.options |= RES_DEFNAMES;
833: } else if (strncmp(option, "nodef", 5) == 0) {
834: _res.options &= ~RES_DEFNAMES;
835: } else if (strncmp(option, "do", 2) == 0) { /* domain */
836: ptr = strchr(option, '=');
837: if (ptr != NULL) {
838: sscanf(++ptr, "%s", _res.defdname);
839: res_re_init();
840: }
841: } else if (strncmp(option, "deb", 1) == 0) { /* debug */
842: _res.options |= RES_DEBUG;
843: } else if (strncmp(option, "nodeb", 5) == 0) {
844: _res.options &= ~(RES_DEBUG | RES_DEBUG2);
845: } else if (strncmp(option, "ig", 2) == 0) { /* ignore */
846: _res.options |= RES_IGNTC;
847: } else if (strncmp(option, "noig", 4) == 0) {
848: _res.options &= ~RES_IGNTC;
849: } else if (strncmp(option, "po", 2) == 0) { /* port */
850: ptr = strchr(option, '=');
851: if (ptr != NULL) {
852: sscanf(++ptr, "%hu", &nsport);
853: }
854: #ifdef deprecated
855: } else if (strncmp(option, "pri", 3) == 0) { /* primary */
856: _res.options |= RES_PRIMARY;
857: } else if (strncmp(option, "nopri", 5) == 0) {
858: _res.options &= ~RES_PRIMARY;
859: #endif
860: } else if (strncmp(option, "q", 1) == 0 || /* querytype */
861: strncmp(option, "ty", 2) == 0) { /* type */
862: ptr = strchr(option, '=');
863: if (ptr != NULL) {
864: sscanf(++ptr, "%s", type);
865: queryType = StringToType(type, queryType);
866: }
867: } else if (strncmp(option, "cl", 2) == 0) { /* query class */
868: ptr = strchr(option, '=');
869: if (ptr != NULL) {
870: sscanf(++ptr, "%s", type);
871: queryClass = StringToClass(type, queryClass);
872: }
873: } else if (strncmp(option, "rec", 3) == 0) { /* recurse */
874: _res.options |= RES_RECURSE;
875: } else if (strncmp(option, "norec", 5) == 0) {
876: _res.options &= ~RES_RECURSE;
877: } else if (strncmp(option, "ret", 3) == 0) { /* retry */
878: ptr = strchr(option, '=');
879: if (ptr != NULL) {
880: sscanf(++ptr, "%d", &tmp);
881: if (tmp >= 0) {
882: _res.retry = tmp;
883: }
884: }
885: } else if (strncmp(option, "ro", 2) == 0) { /* root */
886: ptr = strchr(option, '=');
887: if (ptr != NULL) {
888: sscanf(++ptr, "%s", rootServerName);
889: }
890: } else if (strncmp(option, "sea", 3) == 0) { /* search list */
891: _res.options |= RES_DNSRCH;
892: } else if (strncmp(option, "nosea", 5) == 0) {
893: _res.options &= ~RES_DNSRCH;
894: } else if (strncmp(option, "srchl", 5) == 0) { /* domain search list */
895: ptr = strchr(option, '=');
896: if (ptr != NULL) {
897: res_dnsrch(++ptr);
898: }
899: } else if (strncmp(option, "ti", 2) == 0) { /* timeout */
900: ptr = strchr(option, '=');
901: if (ptr != NULL) {
902: sscanf(++ptr, "%d", &tmp);
903: if (tmp >= 0) {
904: _res.retrans = tmp;
905: }
906: }
907: } else if (strncmp(option, "v", 1) == 0) { /* vc */
908: _res.options |= RES_USEVC;
909: } else if (strncmp(option, "nov", 3) == 0) {
910: _res.options &= ~RES_USEVC;
911: } else {
912: fprintf(stderr, "*** Invalid option: %s\n", option);
913: return(ERROR);
914: }
915: }
916: return(SUCCESS);
917: }
918:
919: /*
920: * Fake a reinitialization when the domain is changed.
921: */
922: res_re_init()
923: {
924: register char *cp, **pp;
925: int n;
926:
927: /* find components of local domain that might be searched */
928: pp = _res.dnsrch;
929: *pp++ = _res.defdname;
930: for (cp = _res.defdname, n = 0; *cp; cp++)
931: if (*cp == '.')
932: n++;
933: cp = _res.defdname;
934: for (; n >= LOCALDOMAINPARTS && pp < _res.dnsrch + MAXDFLSRCH; n--) {
935: cp = strchr(cp, '.');
936: *pp++ = ++cp;
937: }
938: *pp = 0;
939: _res.options |= RES_INIT;
940: }
941:
942: #define SRCHLIST_SEP '/'
943:
944: res_dnsrch(cp)
945: register char *cp;
946: {
947: register char **pp;
948: int n;
949:
950: (void)strncpy(_res.defdname, cp, sizeof(_res.defdname) - 1);
951: if ((cp = strchr(_res.defdname, '\n')) != NULL)
952: *cp = '\0';
953: /*
954: * Set search list to be blank-separated strings
955: * on rest of line.
956: */
957: cp = _res.defdname;
958: pp = _res.dnsrch;
959: *pp++ = cp;
960: for (n = 0; *cp && pp < _res.dnsrch + MAXDNSRCH; cp++) {
961: if (*cp == SRCHLIST_SEP) {
962: *cp = '\0';
963: n = 1;
964: } else if (n) {
965: *pp++ = cp;
966: n = 0;
967: }
968: }
969: if ((cp = strchr(pp[-1], SRCHLIST_SEP)) != NULL) {
970: *cp = '\0';
971: }
972: *pp = NULL;
973: }
974:
975:
976: /*
977: *******************************************************************************
978: *
979: * ShowOptions --
980: *
981: * Prints out the state information used by the resolver
982: * library and other options set by the user.
983: *
984: *******************************************************************************
985: */
986:
987: void
988: ShowOptions()
989: {
990: register char **cp;
991:
992: PrintHostInfo(stdout, "Default Server:", defaultPtr);
993: if (curHostValid) {
994: PrintHostInfo(stdout, "Host:", &curHostInfo);
995: }
996:
997: printf("Set options:\n");
998: printf(" %sdebug \t", (_res.options & RES_DEBUG) ? "" : "no");
999: printf(" %sdefname\t", (_res.options & RES_DEFNAMES) ? "" : "no");
1000: printf(" %ssearch\t", (_res.options & RES_DNSRCH) ? "" : "no");
1001: printf(" %srecurse\n", (_res.options & RES_RECURSE) ? "" : "no");
1002:
1003: printf(" %sd2\t\t", (_res.options & RES_DEBUG2) ? "" : "no");
1004: printf(" %svc\t\t", (_res.options & RES_USEVC) ? "" : "no");
1005: printf(" %signoretc\t", (_res.options & RES_IGNTC) ? "" : "no");
1006: printf(" port=%u\n", nsport);
1007:
1008: printf(" querytype=%s\t", p_type(queryType));
1009: printf(" class=%s\t", p_class(queryClass));
1010: printf(" timeout=%d\t", _res.retrans);
1011: printf(" retry=%d\n", _res.retry);
1012: printf(" root=%s\n", rootServerName);
1013: printf(" domain=%s\n", _res.defdname);
1014:
1015: if (cp = _res.dnsrch) {
1016: printf(" srchlist=%s", *cp);
1017: for (cp++; *cp; cp++) {
1018: printf("%c%s", SRCHLIST_SEP, *cp);
1019: }
1020: putchar('\n');
1021: }
1022: putchar('\n');
1023: }
1024: #undef SRCHLIST_SEP
1025:
1026: /*
1027: *******************************************************************************
1028: *
1029: * PrintHelp --
1030: *
1031: * Prints out the help file.
1032: * (Code taken from Mail.)
1033: *
1034: *******************************************************************************
1035: */
1036:
1037: void
1038: PrintHelp()
1039: {
1040: register int c;
1041: register FILE *helpFilePtr;
1042:
1043: if ((helpFilePtr = fopen(_PATH_HELPFILE, "r")) == NULL) {
1044: perror(_PATH_HELPFILE);
1045: return;
1046: }
1047: while ((c = getc(helpFilePtr)) != EOF) {
1048: putchar((char) c);
1049: }
1050: fclose(helpFilePtr);
1051: }
1052:
1053: /*
1054: *******************************************************************************
1055: *
1056: * CvtAddrToPtr --
1057: *
1058: * Convert a dotted-decimal Internet address into the standard
1059: * PTR format (reversed address with .in-arpa. suffix).
1060: *
1061: * Assumes the argument buffer is large enougth to hold the result.
1062: *
1063: *******************************************************************************
1064: */
1065:
1066: static void
1067: CvtAddrToPtr(name)
1068: char *name;
1069: {
1070: char *p;
1071: int ip[4];
1072: struct in_addr addr;
1073:
1074: if (IsAddr(name, &addr.s_addr)) {
1075: p = inet_ntoa(addr);
1076: if (sscanf(p, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]) == 4) {
1077: sprintf(name, "%d.%d.%d.%d.in-addr.arpa.",
1078: ip[3], ip[2], ip[1], ip[0]);
1079: }
1080: }
1081: }
1082:
1083: /*
1084: *******************************************************************************
1085: *
1086: * ReadRC --
1087: *
1088: * Use the contents of ~/.nslookuprc as options.
1089: *
1090: *******************************************************************************
1091: */
1092:
1093: static void
1094: ReadRC()
1095: {
1096: register FILE *fp;
1097: register char *cp;
1098: char buf[NAME_LEN];
1099:
1100: if ((cp = getenv("HOME")) != NULL) {
1101: (void) strcpy(buf, cp);
1102: (void) strcat(buf, "/.nslookuprc");
1103:
1104: if ((fp = fopen(buf, "r")) != NULL) {
1105: while (fgets(buf, sizeof(buf), fp) != NULL) {
1106: if ((cp = strchr(buf, '\n')) != NULL) {
1107: *cp = '\0';
1108: }
1109: (void) SetOption(buf);
1110: }
1111: (void) fclose(fp);
1112: }
1113: }
1114: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.