![[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] / 43BSDTahoe / etc / named / tools / nslookup|
Return to main.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: char copyright[] = ! 15: "@(#) Copyright (c) 1985 Regents of the University of California.\n\ ! 16: All rights reserved.\n"; ! 17: #endif /* not lint */ ! 18: ! 19: #ifndef lint ! 20: static char sccsid[] = "@(#)main.c 5.15 (Berkeley) 3/26/88"; ! 21: #endif /* not lint */ ! 22: ! 23: /* ! 24: ******************************************************************************* ! 25: * ! 26: * main.c -- ! 27: * ! 28: * Main routine and some action routines for the name server ! 29: * lookup program. ! 30: * ! 31: * Andrew Cherenson CS298-26 Fall 1985 ! 32: * ! 33: ******************************************************************************* ! 34: */ ! 35: ! 36: #include <stdio.h> ! 37: #include <strings.h> ! 38: #include <sys/param.h> ! 39: #include <netdb.h> ! 40: #include <sys/socket.h> ! 41: #include <netinet/in.h> ! 42: #include <arpa/nameser.h> ! 43: #include <resolv.h> ! 44: #include <signal.h> ! 45: #include <setjmp.h> ! 46: #include "res.h" ! 47: ! 48: /* ! 49: * Location of the help file. ! 50: */ ! 51: ! 52: #define HELPFILE "/usr/local/nslookup.help" ! 53: ! 54: ! 55: #if BSD < 43 ! 56: /* ! 57: * Internet address of the current host. ! 58: */ ! 59: ! 60: #define LOCALHOST "127.0.0.1" ! 61: #endif ! 62: ! 63: ! 64: /* ! 65: * Name of a top-level name server. Can be changed with ! 66: * the "set root" command. ! 67: */ ! 68: ! 69: #define ROOT_SERVER "sri-nic.arpa." ! 70: char rootServerName[NAME_LEN]; ! 71: ! 72: ! 73: /* ! 74: * Import the state information from the resolver library. ! 75: */ ! 76: ! 77: extern struct state _res; ! 78: ! 79: ! 80: /* ! 81: * Info about the most recently queried host. ! 82: */ ! 83: ! 84: HostInfo curHostInfo; ! 85: int curHostValid = FALSE; ! 86: ! 87: ! 88: /* ! 89: * Info about the default name server. ! 90: */ ! 91: ! 92: HostInfo *defaultPtr = NULL; ! 93: char defaultServer[NAME_LEN]; ! 94: struct in_addr defaultAddr; ! 95: ! 96: ! 97: /* ! 98: * Initial name server query type is Address. ! 99: */ ! 100: ! 101: int queryType = T_A; ! 102: int queryClass = C_IN; ! 103: ! 104: /* ! 105: * Stuff for Interrupt (control-C) signal handler. ! 106: * SockFD is the file descriptor for sockets used to ! 107: * connect with the name servers. It has to be global to ! 108: * allow the interrupt handler can close open sockets. ! 109: */ ! 110: ! 111: extern int IntrHandler(); ! 112: int sockFD = -1; ! 113: FILE *filePtr; ! 114: jmp_buf env; ! 115: ! 116: ! 117: ! 118: /* ! 119: ******************************************************************************* ! 120: * ! 121: * main -- ! 122: * ! 123: * Initializes the resolver library and determines the address ! 124: * of the initial name server. The yylex routine is used to ! 125: * read and perform commands. ! 126: * ! 127: ******************************************************************************* ! 128: */ ! 129: ! 130: main(argc, argv) ! 131: int argc; ! 132: char **argv; ! 133: { ! 134: int result; ! 135: char hostName[NAME_LEN]; ! 136: char *wantedHost = NULL; ! 137: int useLocalServer; ! 138: int i; ! 139: struct hostent *hp; ! 140: extern int h_errno; ! 141: ! 142: /* ! 143: * Initialize the resolver library routines. ! 144: */ ! 145: ! 146: if (res_init() == -1) { ! 147: fprintf(stderr,"*** Can't initialize resolver.\n"); ! 148: exit(1); ! 149: } ! 150: ! 151: /* ! 152: * Allocate space for the default server's host info and ! 153: * find the server's address and name. If the resolver library ! 154: * already has some addresses for a potential name server, ! 155: * then use them. Otherwise, see if the current host has a server. ! 156: * Command line arguments may override the choice of initial server. ! 157: */ ! 158: ! 159: defaultPtr = (HostInfo *) Calloc(1, sizeof(HostInfo)); ! 160: ! 161: /* ! 162: * Parse the arguments: ! 163: * no args = go into interactive mode, use default host as server ! 164: * 1 arg = use as host name to be looked up, default host will be server ! 165: * non-interactive mode ! 166: * 2 args = 1st arg: ! 167: * if it is '-', then ! 168: * ignore but go into interactive mode ! 169: * else ! 170: * use as host name to be looked up, ! 171: * go into non-interactive mode ! 172: * 2nd arg: name or inet address of server ! 173: * ! 174: */ ! 175: ! 176: useLocalServer = FALSE; ! 177: if (argc > 1) { ! 178: if (argc > 3) { ! 179: Usage(); ! 180: } ! 181: argv++; /* skip prog name */ ! 182: ! 183: if (*argv[0] != '-') { ! 184: wantedHost = *argv; /* name of host to be looked up */ ! 185: } ! 186: if (argc == 3) { ! 187: ! 188: /* ! 189: * Set explicit name server address. ! 190: */ ! 191: ! 192: _res.nscount = 1; ! 193: _res.nsaddr.sin_addr.s_addr = inet_addr(*++argv); ! 194: if (_res.nsaddr.sin_addr.s_addr == (unsigned)-1) { ! 195: hp = gethostbyname(*argv); ! 196: if (hp == NULL){ ! 197: herror(h_errno); ! 198: _res.nscount = 0; ! 199: useLocalServer = TRUE; ! 200: } else { ! 201: #if BSD > 42 ! 202: bcopy(hp->h_addr_list[0], &_res.nsaddr.sin_addr, ! 203: hp->h_length); ! 204: #else ! 205: bcopy(hp->h_addr, &_res.nsaddr.sin_addr, ! 206: hp->h_length); ! 207: #endif ! 208: useLocalServer = FALSE; ! 209: } ! 210: } ! 211: } ! 212: } ! 213: ! 214: ! 215: if (_res.nscount > 0 && !useLocalServer) { ! 216: for (i = 0; i < _res.nscount; i++) { ! 217: if (_res.nsaddr_list[i].sin_addr.s_addr == INADDR_ANY) { ! 218: useLocalServer = TRUE; ! 219: break; ! 220: } else { ! 221: result = FindHostInfo(&(_res.nsaddr_list[i].sin_addr), ! 222: &(_res.nsaddr_list[i].sin_addr), ! 223: sizeof(struct in_addr), ! 224: defaultPtr); ! 225: if (result != SUCCESS) { ! 226: fprintf(stderr, ! 227: "*** Can't find server name for address %s: %s\n", ! 228: inet_ntoa(_res.nsaddr_list[i].sin_addr), ! 229: DecodeError(result)); ! 230: } else { ! 231: defaultAddr = _res.nsaddr_list[i].sin_addr; ! 232: break; ! 233: } ! 234: } ! 235: } ! 236: ! 237: /* ! 238: * If we have exhausted the list, tell the user about the ! 239: * command line argument to specify an address. ! 240: */ ! 241: ! 242: if (i == _res.nscount) { ! 243: fprintf(stderr, ! 244: "*** Default servers are not available\n"); ! 245: exit(1); ! 246: } ! 247: ! 248: } ! 249: gethostname(hostName, sizeof(hostName)); ! 250: #if BSD >= 43 ! 251: strcpy(defaultServer, hostName); ! 252: (void) GetHostInfo(&defaultAddr, C_IN, T_A, "0.0.0.0", defaultPtr, 1); ! 253: defaultPtr->name = hostName; ! 254: #else ! 255: if (useLocalServer) { ! 256: defaultAddr.s_addr = inet_addr(LOCALHOST); ! 257: result = GetHostInfo(&defaultAddr, C_IN, T_A, hostName, defaultPtr, 1); ! 258: if (result != SUCCESS) { ! 259: fprintf(stderr, ! 260: "*** Can't find initialize address for server %s: %s\n", ! 261: defaultServer, DecodeError(result)); ! 262: exit(1); ! 263: } ! 264: } ! 265: strcpy(defaultServer, defaultPtr->name); ! 266: #endif ! 267: ! 268: strcpy(rootServerName, ROOT_SERVER); ! 269: ! 270: ! 271: #ifdef DEBUG ! 272: #ifdef DEBUG2 ! 273: _res.options |= RES_DEBUG2; ! 274: #endif ! 275: _res.options |= RES_DEBUG; ! 276: _res.retry = 2; ! 277: #endif DEBUG ! 278: ! 279: /* ! 280: * If we're in non-interactive mode, look up the wanted host and quit. ! 281: * Otherwise, print the initial server's name and continue with ! 282: * the initialization. ! 283: */ ! 284: ! 285: if (wantedHost != (char *) NULL) { ! 286: LookupHost(wantedHost, 0); ! 287: exit(0); ! 288: } else { ! 289: PrintHostInfo(stdout, "Default Server:", defaultPtr); ! 290: } ! 291: ! 292: /* ! 293: * Setup the environment to allow the interrupt handler to return here. ! 294: */ ! 295: ! 296: (void) setjmp(env); ! 297: ! 298: /* ! 299: * Return here after a longjmp. ! 300: */ ! 301: ! 302: signal(SIGINT, IntrHandler); ! 303: ! 304: /* ! 305: * Read and evaluate commands. The commands are described in commands.l ! 306: * Yylex returns 0 when ^D or 'exit' is typed. ! 307: */ ! 308: ! 309: printf("> "); ! 310: while(yylex()) { ! 311: printf("> "); ! 312: } ! 313: } ! 314: ! 315: ! 316: /* ! 317: ******************************************************************************* ! 318: * ! 319: * Usage -- ! 320: * ! 321: * Lists the proper methods to run the program and exits. ! 322: * ! 323: ******************************************************************************* ! 324: */ ! 325: ! 326: Usage() ! 327: { ! 328: fprintf(stderr, "Usage:\n"); ! 329: fprintf(stderr, ! 330: "\tnslookup # interactive mode using default server\n"); ! 331: fprintf(stderr, ! 332: "\tnslookup - server # interactive mode using 'server'\n"); ! 333: fprintf(stderr, ! 334: "\tnslookup host # just look up 'host' using default server\n"); ! 335: fprintf(stderr, ! 336: "\tnslookup host server # just look up 'host' using 'server'\n"); ! 337: exit(1); ! 338: } ! 339: ! 340: ! 341: /* ! 342: ******************************************************************************* ! 343: * ! 344: * SetDefaultServer -- ! 345: * ! 346: * Changes the default name server to the one specified by ! 347: * the first argument. The command "server name" uses the current ! 348: * default server to lookup the info for "name". The command ! 349: * "lserver name" uses the original server to lookup "name". ! 350: * ! 351: * Side effects: ! 352: * This routine will cause a core dump if the allocation requests fail. ! 353: * ! 354: * Results: ! 355: * SUCCESS The default server was changed successfully. ! 356: * NONAUTH The server was changed but addresses of ! 357: * other servers who know about the requested server ! 358: * were returned. ! 359: * Errors No info about the new server was found or ! 360: * requests to the current server timed-out. ! 361: * ! 362: ******************************************************************************* ! 363: */ ! 364: ! 365: int ! 366: SetDefaultServer(string, local) ! 367: char *string; ! 368: int local; ! 369: { ! 370: register HostInfo *newDefPtr; ! 371: char newServer[NAME_LEN]; ! 372: int result; ! 373: int i; ! 374: ! 375: /* ! 376: * Parse the command line. It maybe of the form "server name", ! 377: * "lserver name" or just "name". ! 378: */ ! 379: ! 380: if (local) { ! 381: i = sscanf(string, " lserver %s", newServer); ! 382: } else { ! 383: i = sscanf(string, " server %s", newServer); ! 384: } ! 385: if (i != 1) { ! 386: i = sscanf(string, " %s", newServer); ! 387: if (i != 1) { ! 388: fprintf(stderr,"SetDefaultServer: invalid name: %s\n", string); ! 389: return(ERROR); ! 390: } ! 391: } ! 392: ! 393: /* ! 394: * Allocate space for a HostInfo variable for the new server. Don't ! 395: * overwrite the old HostInfo struct because info about the new server ! 396: * might not be found and we need to have valid default server info. ! 397: */ ! 398: ! 399: newDefPtr = (HostInfo *) Calloc(1, sizeof(HostInfo)); ! 400: ! 401: ! 402: /* ! 403: * A 'local' lookup uses the original server that the program was ! 404: * initialized with. ! 405: */ ! 406: ! 407: if (local) { ! 408: result = GetHostInfo(&defaultAddr, C_IN, T_A, newServer, newDefPtr, 1); ! 409: } else { ! 410: ! 411: /* ! 412: * Check to see if we have the address of the server or the ! 413: * address of a server who knows about this domain. ! 414: * ! 415: * For now, just use the first address in the list. ! 416: */ ! 417: if (defaultPtr->addrList == NULL) { ! 418: result = GetHostInfo( ! 419: (struct in_addr *) defaultPtr->servers[0]->addrList[0], ! 420: C_IN, T_A, newServer, newDefPtr, 1); ! 421: } else { ! 422: result = GetHostInfo((struct in_addr *) defaultPtr->addrList[0], ! 423: C_IN, T_A, newServer, newDefPtr, 1); ! 424: } ! 425: } ! 426: ! 427: if (result == SUCCESS || result == NONAUTH) { ! 428: /* ! 429: * Found info about the new server. Free the resources for ! 430: * the old server. ! 431: */ ! 432: ! 433: FreeHostInfoPtr(defaultPtr); ! 434: free((char *)defaultPtr); ! 435: defaultPtr = newDefPtr; ! 436: strcpy(defaultServer, defaultPtr->name); ! 437: PrintHostInfo(stdout, "Default Server:", defaultPtr); ! 438: return(SUCCESS); ! 439: } else { ! 440: fprintf(stderr, "*** Can't find address for server %s: %s\n", ! 441: newServer, DecodeError(result)); ! 442: free((char *)newDefPtr); ! 443: ! 444: return(result); ! 445: } ! 446: } ! 447: ! 448: /* ! 449: ******************************************************************************* ! 450: * ! 451: * LookupHost -- ! 452: * ! 453: * Asks the default name server for information about the ! 454: * specified host or domain. The information is printed ! 455: * if the lookup was successful. ! 456: * ! 457: * Results: ! 458: * SUCCESS - the lookup was successful. ! 459: * ERROR - the output file could not be opened. ! 460: * Misc. Errors - an error message is printed if the lookup failed. ! 461: * ! 462: ******************************************************************************* ! 463: */ ! 464: ! 465: int ! 466: LookupHost(string, putToFile) ! 467: char *string; ! 468: int putToFile; ! 469: { ! 470: char host[NAME_LEN]; ! 471: char file[NAME_LEN]; ! 472: int result; ! 473: ! 474: /* ! 475: * Invalidate the current host information to prevent Finger ! 476: * from using bogus info. ! 477: */ ! 478: ! 479: curHostValid = FALSE; ! 480: ! 481: /* ! 482: * Parse the command string into the host and ! 483: * optional output file name. ! 484: * ! 485: */ ! 486: ! 487: sscanf(string, " %s", host); /* removes white space */ ! 488: if (!putToFile) { ! 489: filePtr = stdout; ! 490: } else { ! 491: filePtr = OpenFile(string, file); ! 492: if (filePtr == NULL) { ! 493: fprintf(stderr, "*** Can't open %s for writing\n", file); ! 494: return(ERROR); ! 495: } ! 496: fprintf(filePtr,"> %s\n", string); ! 497: } ! 498: ! 499: PrintHostInfo(filePtr, "Server:", defaultPtr); ! 500: ! 501: /* ! 502: * Check to see if we have the address of the server or the ! 503: * address of a server who knows about this domain. ! 504: * ! 505: * For now, just use the first address in the list. ! 506: */ ! 507: ! 508: if (defaultPtr->addrList == NULL) { ! 509: result = GetHostInfo( ! 510: (struct in_addr *) defaultPtr->servers[0]->addrList[0], ! 511: queryClass, queryType, host, &curHostInfo, 0); ! 512: } else { ! 513: result = GetHostInfo((struct in_addr *) defaultPtr->addrList[0], ! 514: queryClass, queryType, host, &curHostInfo, 0); ! 515: } ! 516: ! 517: switch(result) { ! 518: case SUCCESS: ! 519: /* ! 520: * If the query was for an address, then the curHostInfo ! 521: * variable can be used by Finger. ! 522: * There's no need to print anything for other query types ! 523: * because the info has already been printed. ! 524: */ ! 525: if (queryType == T_A) { ! 526: curHostValid = TRUE; ! 527: PrintHostInfo(filePtr, "Name:", &curHostInfo); ! 528: } ! 529: break; ! 530: ! 531: /* ! 532: * No Authoritative answer was available but we got names ! 533: * of servers who know about the host. ! 534: */ ! 535: case NONAUTH: ! 536: PrintHostInfo(filePtr, "Name:", &curHostInfo); ! 537: break; ! 538: ! 539: case NO_INFO: ! 540: fprintf(stderr, "*** No %s information is available for %s\n", ! 541: DecodeType(queryType), host); ! 542: break; ! 543: ! 544: case TIME_OUT: ! 545: fprintf(stderr, "*** Request to %s timed-out\n", defaultServer); ! 546: break; ! 547: ! 548: default: ! 549: fprintf(stderr, "*** %s can't find %s: %s\n", defaultServer, host, ! 550: DecodeError(result)); ! 551: } ! 552: if (putToFile) { ! 553: fclose(filePtr); ! 554: filePtr = NULL; ! 555: } ! 556: return(result); ! 557: } ! 558: ! 559: /* ! 560: ******************************************************************************* ! 561: * ! 562: * LookupHostWithServer -- ! 563: * ! 564: * Asks the name server specified in the second argument for ! 565: * information about the host or domain specified in the first ! 566: * argument. The information is printed if the lookup was successful. ! 567: * ! 568: * Address info about the requested name server is obtained ! 569: * from the default name server. This routine will return an ! 570: * error if the default server doesn't have info about the ! 571: * requested server. Thus an error return status might not ! 572: * mean the requested name server doesn't have info about the ! 573: * requested host. ! 574: * ! 575: * Comments from LookupHost apply here, too. ! 576: * ! 577: * Results: ! 578: * SUCCESS - the lookup was successful. ! 579: * ERROR - the output file could not be opened. ! 580: * Misc. Errors - an error message is printed if the lookup failed. ! 581: * ! 582: ******************************************************************************* ! 583: */ ! 584: ! 585: int ! 586: LookupHostWithServer(string, putToFile) ! 587: char *string; ! 588: int putToFile; ! 589: { ! 590: char file[NAME_LEN]; ! 591: char host[NAME_LEN]; ! 592: char server[NAME_LEN]; ! 593: int result; ! 594: static HostInfo serverInfo; ! 595: ! 596: curHostValid = FALSE; ! 597: ! 598: sscanf(string, " %s %s", host, server); ! 599: if (!putToFile) { ! 600: filePtr = stdout; ! 601: } else { ! 602: filePtr = OpenFile(string, file); ! 603: if (filePtr == NULL) { ! 604: fprintf(stderr, "*** Can't open %s for writing\n", file); ! 605: return(ERROR); ! 606: } ! 607: fprintf(filePtr,"> %s\n", string); ! 608: } ! 609: ! 610: ! 611: if (defaultPtr->addrList == NULL) { ! 612: result = GetHostInfo( ! 613: (struct in_addr *) defaultPtr->servers[0]->addrList[0], ! 614: C_IN, T_A, server, &serverInfo, 1); ! 615: } else { ! 616: result = GetHostInfo((struct in_addr *) defaultPtr->addrList[0], ! 617: C_IN, T_A, server, &serverInfo, 1); ! 618: } ! 619: ! 620: if (result != SUCCESS) { ! 621: fprintf(stderr,"*** Can't find address for server %s: %s\n", server, ! 622: DecodeError(result)); ! 623: } else { ! 624: PrintHostInfo(filePtr, "Server:", &serverInfo); ! 625: ! 626: if (serverInfo.addrList == NULL) { ! 627: result = GetHostInfo( ! 628: (struct in_addr *) serverInfo.servers[0]->addrList[0], ! 629: queryClass, queryType, host, &curHostInfo, 0); ! 630: } else { ! 631: result = GetHostInfo((struct in_addr *) serverInfo.addrList[0], ! 632: queryClass, queryType, host, &curHostInfo, 0); ! 633: } ! 634: ! 635: ! 636: switch(result) { ! 637: ! 638: case SUCCESS: ! 639: if (queryType == T_A) { ! 640: curHostValid = TRUE; ! 641: PrintHostInfo(filePtr, "Name:", &curHostInfo); ! 642: } ! 643: break; ! 644: ! 645: case NONAUTH: ! 646: PrintHostInfo(filePtr, "Name:", &curHostInfo); ! 647: break; ! 648: ! 649: case NO_INFO: ! 650: fprintf(stderr, "*** No %s information is available for %s\n", ! 651: DecodeType(queryType), host); ! 652: break; ! 653: ! 654: case TIME_OUT: ! 655: fprintf(stderr, "*** Request to %s timed-out\n", server); ! 656: break; ! 657: ! 658: default: ! 659: fprintf(stderr, "*** %s can't find %s: %s\n", server, host, ! 660: DecodeError(result)); ! 661: } ! 662: } ! 663: if (putToFile) { ! 664: fclose(filePtr); ! 665: filePtr = NULL; ! 666: } ! 667: return(result); ! 668: } ! 669: ! 670: /* ! 671: ******************************************************************************* ! 672: * ! 673: * SetOption -- ! 674: * ! 675: * This routine is used to change the state information ! 676: * that affect the lookups. The command format is ! 677: * set keyword[=value] ! 678: * Most keywords can be abbreviated. Parsing is very simplistic-- ! 679: * A value must not be separated from its keyword by white space. ! 680: * ! 681: * Valid keywords: Meaning: ! 682: * [no]aaonly authoritative query only or not (hidden). ! 683: * all lists current values of options. ! 684: * ALL lists current values of options, including ! 685: * hidden options. ! 686: * [no]d2 turn on/off extra debugging mode (hidden). ! 687: * [no]debug turn on/off debugging mode. ! 688: * [no]defname use/don't use default domain name. ! 689: * [no]search use/don't use domain search list. ! 690: * domain=NAME set default domain name to NAME. ! 691: * [no]ignore ignore/don't ignore trunc. errors (hidden). ! 692: * [no]primary use/don't use primary server (hidden). ! 693: * query=value set default query type to value, ! 694: * value is one of the query types in RFC883 ! 695: * without the leading T_. (e.g. A, HINFO) ! 696: * [no]recurse use/don't use recursive lookup. ! 697: * retry=# set number of retries to #. ! 698: * root=NAME change root server to NAME. ! 699: * time=# set timeout length to #. ! 700: * [no]vc use/don't use virtual circuit. ! 701: * ! 702: * Results: ! 703: * SUCCESS the command was parsed correctly. ! 704: * ERROR the command was not parsed correctly. ! 705: * ! 706: ******************************************************************************* ! 707: */ ! 708: ! 709: int ! 710: SetOption(string) ! 711: char *string; ! 712: { ! 713: char option[NAME_LEN]; ! 714: char type[NAME_LEN]; ! 715: char *ptr; ! 716: int i; ! 717: ! 718: i = sscanf(string, " set %s", option); ! 719: if (i != 1) { ! 720: fprintf(stderr, "*** Invalid option: %s\n", option); ! 721: return(ERROR); ! 722: } else { ! 723: if (strncmp(option, "all", 3) == 0) { ! 724: ShowOptions(FALSE); ! 725: } else if (strncmp(option, "ALL", 3) == 0) { ! 726: ShowOptions(TRUE); ! 727: } else if (strncmp(option, "aa", 2) == 0) { /* aaonly */ ! 728: _res.options |= RES_AAONLY; ! 729: } else if (strncmp(option, "noaa", 4) == 0) { ! 730: _res.options &= ~RES_AAONLY; ! 731: } else if (strncmp(option, "deb", 3) == 0) { /* debug */ ! 732: _res.options |= RES_DEBUG; ! 733: } else if (strncmp(option, "nodeb", 5) == 0) { ! 734: _res.options &= ~(RES_DEBUG | RES_DEBUG2); ! 735: } else if (strncmp(option, "d2", 2) == 0) { /* d2 (more debug) */ ! 736: _res.options |= (RES_DEBUG | RES_DEBUG2); ! 737: } else if (strncmp(option, "nod2", 4) == 0) { ! 738: _res.options &= ~RES_DEBUG2; ! 739: } else if (strncmp(option, "def", 3) == 0) { /* defname */ ! 740: _res.options |= RES_DEFNAMES; ! 741: } else if (strncmp(option, "nodef", 5) == 0) { ! 742: _res.options &= ~RES_DEFNAMES; ! 743: } else if (strncmp(option, "sea", 3) == 0) { /* search list */ ! 744: _res.options |= RES_DNSRCH; ! 745: } else if (strncmp(option, "nosea", 5) == 0) { ! 746: _res.options &= ~RES_DNSRCH; ! 747: } else if (strncmp(option, "do", 2) == 0) { /* domain */ ! 748: ptr = index(option, '='); ! 749: if (ptr != NULL) { ! 750: sscanf(++ptr, "%s", _res.defdname); ! 751: res_re_init(); ! 752: } ! 753: } else if (strncmp(option, "i", 1) == 0) { /* ignore */ ! 754: _res.options |= RES_IGNTC; ! 755: } else if (strncmp(option, "noi", 3) == 0) { ! 756: _res.options &= ~RES_IGNTC; ! 757: } else if (strncmp(option, "p", 1) == 0) { /* primary */ ! 758: _res.options |= RES_PRIMARY; ! 759: } else if (strncmp(option, "nop", 3) == 0) { ! 760: _res.options &= ~RES_PRIMARY; ! 761: } else if (strncmp(option, "q", 1) == 0 || /* querytype */ ! 762: strncmp(option, "ty", 2) == 0) { ! 763: ptr = index(option, '='); ! 764: if (ptr != NULL) { ! 765: sscanf(++ptr, "%s", type); ! 766: queryType = StringToType(type, queryType); ! 767: } ! 768: } else if (strncmp(option, "cl", 2) == 0) { /* query class */ ! 769: ptr = index(option, '='); ! 770: if (ptr != NULL) { ! 771: sscanf(++ptr, "%s", type); ! 772: queryClass = StringToClass(type, queryClass); ! 773: } ! 774: } else if (strncmp(option, "rec", 3) == 0) { /* recurse */ ! 775: _res.options |= RES_RECURSE; ! 776: } else if (strncmp(option, "norec", 5) == 0) { ! 777: _res.options &= ~RES_RECURSE; ! 778: } else if (strncmp(option, "ret", 3) == 0) { /* retry */ ! 779: ptr = index(option, '='); ! 780: if (ptr != NULL) { ! 781: sscanf(++ptr, "%d", &_res.retry); ! 782: } ! 783: } else if (strncmp(option, "ro", 2) == 0) { /* root */ ! 784: ptr = index(option, '='); ! 785: if (ptr != NULL) { ! 786: sscanf(++ptr, "%s", rootServerName); ! 787: } ! 788: } else if (strncmp(option, "t", 1) == 0) { /* timeout */ ! 789: ptr = index(option, '='); ! 790: if (ptr != NULL) { ! 791: sscanf(++ptr, "%d", &_res.retrans); ! 792: } ! 793: } else if (strncmp(option, "v", 1) == 0) { /* vc */ ! 794: _res.options |= RES_USEVC; ! 795: } else if (strncmp(option, "nov", 3) == 0) { ! 796: _res.options &= ~RES_USEVC; ! 797: } else { ! 798: fprintf(stderr, "*** Invalid option: %s\n", option); ! 799: return(ERROR); ! 800: } ! 801: } ! 802: return(SUCCESS); ! 803: } ! 804: ! 805: /* ! 806: * Fake a reinitialization when the domain is changed. ! 807: */ ! 808: res_re_init() ! 809: { ! 810: register char *cp, **pp; ! 811: int n; ! 812: ! 813: /* find components of local domain that might be searched */ ! 814: pp = _res.dnsrch; ! 815: *pp++ = _res.defdname; ! 816: for (cp = _res.defdname, n = 0; *cp; cp++) ! 817: if (*cp == '.') ! 818: n++; ! 819: cp = _res.defdname; ! 820: for (; n >= LOCALDOMAINPARTS && pp < _res.dnsrch + MAXDNSRCH; n--) { ! 821: cp = index(cp, '.'); ! 822: *pp++ = ++cp; ! 823: } ! 824: *pp = 0; ! 825: _res.options |= RES_INIT; ! 826: } ! 827: ! 828: /* ! 829: ******************************************************************************* ! 830: * ! 831: * ShowOptions -- ! 832: * ! 833: * Prints out the state information used by the resolver ! 834: * library and other options set by the user. ! 835: * ! 836: ******************************************************************************* ! 837: */ ! 838: ! 839: void ! 840: ShowOptions(special) ! 841: int special; ! 842: { ! 843: int i; ! 844: register char **cp; ! 845: ! 846: PrintHostInfo(stdout, "Default Server:", defaultPtr); ! 847: if (curHostValid) { ! 848: PrintHostInfo(stdout, "Host:", &curHostInfo); ! 849: } ! 850: ! 851: printf("Set options:\n"); ! 852: printf(" %sdebug \t", (_res.options & RES_DEBUG) ? "" : "no"); ! 853: printf(" %sdefname\t", (_res.options & RES_DEFNAMES) ? "" : "no"); ! 854: printf(" %ssearch\t", (_res.options & RES_DNSRCH) ? "" : "no"); ! 855: printf(" %srecurse\t", (_res.options & RES_RECURSE) ? "" : "no"); ! 856: printf(" %svc\n", (_res.options & RES_USEVC) ? "" : "no"); ! 857: ! 858: if (special) { ! 859: printf(" %saa\t\t", (_res.options & RES_AAONLY) ? "" : "no"); ! 860: printf(" %sd2\t\t", (_res.options & RES_DEBUG2) ? "" : "no"); ! 861: printf(" %signoretc\t", (_res.options & RES_IGNTC) ? "" : "no"); ! 862: printf(" %sprimary\n", (_res.options & RES_PRIMARY) ? "" : "no"); ! 863: } ! 864: ! 865: printf(" querytype=%s\t", p_type(queryType)); ! 866: printf(" class=%s\t", p_class(queryClass)); ! 867: printf(" timeout=%d\t", _res.retrans); ! 868: printf(" retry=%d\n", _res.retry); ! 869: printf(" domain=%s\n", _res.defdname); ! 870: printf(" search list: "); ! 871: for (cp = _res.dnsrch; *cp; cp++) ! 872: printf("%s ", *cp); ! 873: printf("\n root=%s\n", rootServerName); ! 874: ! 875: if (special) { ! 876: printf("\n"); ! 877: printf("State info:\n"); ! 878: printf(" current packet id: %d\n", _res.id); ! 879: printf(" number of name servers: %d\n", _res.nscount); ! 880: printf(" name server addresses: %s\n", ! 881: inet_ntoa(_res.nsaddr_list[0].sin_addr)); ! 882: for (i = 1; i < _res.nscount; i++) { ! 883: printf(" %s\n", ! 884: inet_ntoa(_res.nsaddr_list[i].sin_addr)); ! 885: } ! 886: } ! 887: } ! 888: ! 889: /* ! 890: ******************************************************************************* ! 891: * ! 892: * PrintHelp -- ! 893: * ! 894: * Prints out the help file. ! 895: * (Code taken from Mail.) ! 896: * ! 897: ******************************************************************************* ! 898: */ ! 899: ! 900: void ! 901: PrintHelp() ! 902: { ! 903: register int c; ! 904: register FILE *helpFilePtr; ! 905: ! 906: if ((helpFilePtr = fopen(HELPFILE, "r")) == NULL) { ! 907: perror(HELPFILE); ! 908: return; ! 909: } ! 910: while ((c = getc(helpFilePtr)) != EOF) { ! 911: putchar((char) c); ! 912: } ! 913: fclose(helpFilePtr); ! 914: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.