![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to getinfo.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 getinfo.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[] = "@(#)getinfo.c 5.16 (Berkeley) 3/11/88"; ! 15: #endif /* not lint */ ! 16: ! 17: /* ! 18: ******************************************************************************* ! 19: * ! 20: * getinfo.c -- ! 21: * ! 22: * Routines to create requests to name servers ! 23: * and interpret the answers. ! 24: * ! 25: * Adapted from 4.3BSD BIND gethostnamadr.c ! 26: * ! 27: ******************************************************************************* ! 28: */ ! 29: ! 30: #include <sys/types.h> ! 31: #include <sys/socket.h> ! 32: #include <netinet/in.h> ! 33: #include <stdio.h> ! 34: #include <ctype.h> ! 35: #include <arpa/nameser.h> ! 36: #include <resolv.h> ! 37: #include "res.h" ! 38: ! 39: extern char *_res_resultcodes[]; ! 40: extern char *res_skip(); ! 41: ! 42: #define MAXALIASES 35 ! 43: #define MAXADDRS 35 ! 44: #define MAXDOMAINS 35 ! 45: #define MAXSERVERS 10 ! 46: ! 47: static char *addr_list[MAXADDRS + 1]; ! 48: ! 49: static char *host_aliases[MAXALIASES]; ! 50: static int host_aliases_len[MAXALIASES]; ! 51: static char hostbuf[BUFSIZ+1]; ! 52: ! 53: typedef struct { ! 54: char *name; ! 55: char *domain[MAXDOMAINS]; ! 56: int numDomains; ! 57: char *address[MAXADDRS]; ! 58: int numAddresses; ! 59: } ServerTable; ! 60: ! 61: ServerTable server[MAXSERVERS]; ! 62: ! 63: typedef union { ! 64: HEADER qb1; ! 65: char qb2[PACKETSZ]; ! 66: } querybuf; ! 67: ! 68: static union { ! 69: long al; ! 70: char ac; ! 71: } align; ! 72: ! 73: ! 74: /* ! 75: ******************************************************************************* ! 76: * ! 77: * GetAnswer -- ! 78: * ! 79: * Interprets an answer packet and retrieves the following ! 80: * information: ! 81: * ! 82: * Results: ! 83: * SUCCESS the info was retrieved. ! 84: * NO_INFO the packet did not contain an answer. ! 85: * NONAUTH non-authoritative information was found. ! 86: * ERROR the answer was malformed. ! 87: * Other errors returned in the packet header. ! 88: * ! 89: ******************************************************************************* ! 90: */ ! 91: ! 92: static int ! 93: GetAnswer(nsAddrPtr, queryType, msg, msglen, iquery, hostPtr, isserver) ! 94: struct in_addr *nsAddrPtr; ! 95: char *msg; ! 96: int queryType; ! 97: int msglen; ! 98: int iquery; ! 99: register HostInfo *hostPtr; ! 100: int isserver; ! 101: { ! 102: register HEADER *headerPtr; ! 103: register char *cp; ! 104: querybuf answer; ! 105: char *eom, *bp, **aliasPtr; ! 106: char **addrPtr; ! 107: char *namePtr; ! 108: char *dnamePtr; ! 109: int type, class; ! 110: int qdcount, ancount, arcount, nscount, buflen; ! 111: int haveanswer, getclass; ! 112: int numAliases = 0; ! 113: int numAddresses = 0; ! 114: int n, i, j; ! 115: int len; ! 116: int dlen; ! 117: int status; ! 118: int numServers; ! 119: int found; ! 120: ! 121: ! 122: /* ! 123: * If the hostPtr was used before, free up ! 124: * the calloc'd areas. ! 125: */ ! 126: FreeHostInfoPtr(hostPtr); ! 127: ! 128: status = SendRequest(nsAddrPtr, msg, msglen, (char *) &answer, ! 129: sizeof(answer), &n, !isserver); ! 130: ! 131: if (status != SUCCESS) { ! 132: if (_res.options & RES_DEBUG2) ! 133: printf("SendRequest failed\n"); ! 134: return (status); ! 135: } ! 136: eom = (char *) &answer + n; ! 137: ! 138: headerPtr = (HEADER *) &answer; ! 139: qdcount = ntohs(headerPtr->qdcount); ! 140: ancount = ntohs(headerPtr->ancount); ! 141: arcount = ntohs(headerPtr->arcount); ! 142: nscount = ntohs(headerPtr->nscount); ! 143: ! 144: if (headerPtr->rcode != NOERROR) { ! 145: if (_res.options & RES_DEBUG && !isserver) { ! 146: printf( ! 147: "Failed: %s, num. answers = %d, ns = %d, additional = %d\n", ! 148: _res_resultcodes[headerPtr->rcode], ancount, nscount, ! 149: arcount); ! 150: } ! 151: return (headerPtr->rcode); ! 152: } ! 153: ! 154: /* ! 155: * If there are no answer, n.s. or additional records ! 156: * then return with an error. ! 157: */ ! 158: if (ancount == 0 && nscount == 0 && arcount == 0) { ! 159: return (NO_INFO); ! 160: } ! 161: ! 162: ! 163: bp = hostbuf; ! 164: buflen = sizeof(hostbuf); ! 165: cp = (char *) &answer + sizeof(HEADER); ! 166: ! 167: /* ! 168: * For inverse queries, the desired information is returned ! 169: * in the question section. If there are no question records, ! 170: * return with an error. ! 171: * ! 172: */ ! 173: if (qdcount) { ! 174: if (iquery) { ! 175: if ((n = dn_expand((char *)&answer, eom, cp, bp, buflen)) < 0) { ! 176: return (ERROR); ! 177: } ! 178: cp += n + QFIXEDSZ; ! 179: len = strlen(bp) + 1; ! 180: hostPtr->name = Calloc((unsigned)1, (unsigned)len); ! 181: bcopy(bp, hostPtr->name, len); ! 182: } else { ! 183: cp += dn_skipname(cp, eom) + QFIXEDSZ; ! 184: } ! 185: while (--qdcount > 0) { ! 186: cp += dn_skipname(cp, eom) + QFIXEDSZ; ! 187: } ! 188: } else if (iquery) { ! 189: return (NO_INFO); ! 190: } ! 191: ! 192: aliasPtr = host_aliases; ! 193: addrPtr = addr_list; ! 194: haveanswer = 0; ! 195: ! 196: /* ! 197: * Scan through the answer resource records. ! 198: * Answers for address query types are saved. ! 199: * Other query type answers are just printed. ! 200: */ ! 201: if (isserver == 0 && !headerPtr->aa && headerPtr->ancount) ! 202: printf("Non-authoritative answer:\n"); ! 203: while (--ancount >= 0 && cp < eom) { ! 204: if (queryType != T_A) { ! 205: if ((cp = Print_rr(cp, (char *) &answer, eom, stdout)) == NULL) { ! 206: return(ERROR); ! 207: } ! 208: continue; ! 209: } else { ! 210: if ((n = dn_expand((char *) &answer, eom, cp, bp, buflen)) < 0) { ! 211: return(ERROR); ! 212: } ! 213: cp += n; ! 214: type = _getshort(cp); ! 215: cp += sizeof(u_short); ! 216: class = _getshort(cp); ! 217: cp += sizeof(u_short) + sizeof(u_long); ! 218: dlen = _getshort(cp); ! 219: cp += sizeof(u_short); ! 220: if (type == T_CNAME) { ! 221: /* ! 222: * Found an alias. ! 223: */ ! 224: cp += dlen; ! 225: if (aliasPtr >= &host_aliases[MAXALIASES-1]) ! 226: continue; ! 227: *aliasPtr++ = bp; ! 228: n = strlen(bp) + 1; ! 229: host_aliases_len[numAliases] = n; ! 230: numAliases++; ! 231: bp += n; ! 232: buflen -= n; ! 233: continue; ! 234: } else if (type == T_PTR) { ! 235: /* ! 236: * Found a "pointer" to the real name. ! 237: */ ! 238: if((n= dn_expand((char *)&answer, eom, cp, bp, buflen)) < 0){ ! 239: cp += n; ! 240: continue; ! 241: } ! 242: cp += n; ! 243: len = strlen(bp) + 1; ! 244: hostPtr->name = Calloc((unsigned)1, (unsigned)len); ! 245: bcopy(bp, hostPtr->name, len); ! 246: haveanswer = 1; ! 247: break; ! 248: } else if (type != T_A) { ! 249: cp += dlen; ! 250: continue; ! 251: } ! 252: if (haveanswer) { ! 253: if (n != hostPtr->addrLen) { ! 254: cp += dlen; ! 255: continue; ! 256: } ! 257: if (class != getclass) { ! 258: cp += dlen; ! 259: continue; ! 260: } ! 261: } else { ! 262: hostPtr->addrLen = dlen; ! 263: getclass = class; ! 264: hostPtr->addrType = (class == C_IN) ? AF_INET : AF_UNSPEC; ! 265: if (!iquery) { ! 266: len = strlen(bp) + 1; ! 267: hostPtr->name = Calloc((unsigned)1, (unsigned)len); ! 268: bcopy(bp, hostPtr->name, len); ! 269: } ! 270: } ! 271: bp += (((u_long)bp) % sizeof(align)); ! 272: ! 273: if (bp + dlen >= &hostbuf[sizeof(hostbuf)]) { ! 274: if (_res.options & RES_DEBUG) ! 275: printf("Size (%d) too big\n", dlen); ! 276: break; ! 277: } ! 278: bcopy(cp, *addrPtr++ = bp, dlen); ! 279: bp +=dlen; ! 280: cp += dlen; ! 281: numAddresses++; ! 282: haveanswer = 1; ! 283: } ! 284: } ! 285: ! 286: if (queryType == T_A && haveanswer) { ! 287: ! 288: /* ! 289: * Go through the alias and address lists and return them ! 290: * in the hostPtr variable. ! 291: */ ! 292: ! 293: if (numAliases > 0) { ! 294: hostPtr->aliases = (char **) Calloc((unsigned)1+numAliases, ! 295: sizeof(char *)); ! 296: for (i = 0; i < numAliases; i++) { ! 297: hostPtr->aliases[i] = Calloc((unsigned)1, (unsigned)host_aliases_len[i]); ! 298: bcopy(host_aliases[i], hostPtr->aliases[i], ! 299: host_aliases_len[i]); ! 300: } ! 301: hostPtr->aliases[i] = NULL; ! 302: } ! 303: if (numAddresses > 0) { ! 304: hostPtr->addrList = (char **) Calloc((unsigned)1+numAddresses, ! 305: sizeof(char *)); ! 306: for (i = 0; i < numAddresses; i++) { ! 307: hostPtr->addrList[i] = Calloc((unsigned)1, (unsigned)hostPtr->addrLen); ! 308: bcopy(addr_list[i], hostPtr->addrList[i], ! 309: hostPtr->addrLen); ! 310: } ! 311: hostPtr->addrList[i] = NULL; ! 312: } ! 313: hostPtr->servers= NULL; ! 314: return (SUCCESS); ! 315: } ! 316: ! 317: /* ! 318: * At this point, for the T_A query type, only empty answers remain. ! 319: * For other query types, additional information might be found ! 320: * in the additional resource records part. ! 321: */ ! 322: ! 323: cp = res_skip((char *) &answer, 2, eom); ! 324: ! 325: numServers = 0; ! 326: while (--nscount >= 0 && cp < eom) { ! 327: /* ! 328: * Go through the NS records and retrieve the ! 329: * names of hosts that server the requested domain, ! 330: * their addresses and other domains they might serve. ! 331: */ ! 332: ! 333: if ((n = dn_expand((char *) &answer, eom, cp, bp, buflen)) < 0) { ! 334: return(ERROR); ! 335: } ! 336: cp += n; ! 337: len = strlen(bp) + 1; ! 338: dnamePtr = Calloc((unsigned)1, (unsigned)len); /* domain name */ ! 339: bcopy(bp, dnamePtr, len); ! 340: ! 341: type = _getshort(cp); ! 342: cp += sizeof(u_short); ! 343: class = _getshort(cp); ! 344: cp += sizeof(u_short) + sizeof(u_long); ! 345: dlen = _getshort(cp); ! 346: cp += sizeof(u_short); ! 347: ! 348: if (type != T_NS) { ! 349: cp += dlen; ! 350: } else { ! 351: if ((n = dn_expand((char *) &answer, eom, cp, bp, buflen)) < 0) { ! 352: return(ERROR); ! 353: } ! 354: cp += n; ! 355: len = strlen(bp) + 1; ! 356: namePtr = Calloc((unsigned)1, (unsigned)len); /* server host name */ ! 357: bcopy(bp, namePtr, len); ! 358: ! 359: /* ! 360: * Store the information keyed by the server host name. ! 361: */ ! 362: found = FALSE; ! 363: for (j = 0; j < numServers; j++) { ! 364: if (strcmp(namePtr, server[j].name) == 0) { ! 365: found = TRUE; ! 366: free(namePtr); ! 367: break; ! 368: } ! 369: } ! 370: if (found) { ! 371: server[j].numDomains++; ! 372: if (server[j].numDomains <= MAXDOMAINS) { ! 373: server[j].domain[server[j].numDomains-1] = dnamePtr; ! 374: } ! 375: } else { ! 376: if (numServers > MAXSERVERS) { ! 377: break; ! 378: } ! 379: numServers++; ! 380: server[numServers -1].name = namePtr; ! 381: server[numServers -1].domain[0] = dnamePtr; ! 382: server[numServers -1].numDomains = 1; ! 383: server[numServers -1].numAddresses = 0; ! 384: } ! 385: } ! 386: } ! 387: ! 388: if (!headerPtr->aa && (queryType != T_A) && arcount > 0) { ! 389: printf("Authoritative answers can be found from:\n"); ! 390: } ! 391: ! 392: /* ! 393: * Additional resource records contain addresses of ! 394: * servers. ! 395: */ ! 396: cp = res_skip((char *) &answer, 3, eom); ! 397: while (--arcount >= 0 && cp < eom) { ! 398: /* ! 399: * If we don't need to save the record, just print it. ! 400: */ ! 401: if (queryType != T_A) { ! 402: if ((cp = Print_rr(cp, (char *) &answer, eom, stdout)) == NULL) { ! 403: return(ERROR); ! 404: } ! 405: continue; ! 406: ! 407: } else { ! 408: if ((n = dn_expand((char *) &answer, eom, cp, bp, buflen)) < 0) ! 409: break; ! 410: cp += n; ! 411: type = _getshort(cp); ! 412: cp += sizeof(u_short); ! 413: class = _getshort(cp); ! 414: cp += sizeof(u_short) + sizeof(u_long); ! 415: dlen = _getshort(cp); ! 416: cp += sizeof(u_short); ! 417: ! 418: if (type != T_A) { ! 419: cp += dlen; ! 420: continue; ! 421: } else { ! 422: for (j = 0; j < numServers; j++) { ! 423: if (strcmp(bp, server[j].name) == 0) { ! 424: server[j].numAddresses++; ! 425: if (server[j].numAddresses <= MAXADDRS) { ! 426: server[j].address[server[j].numAddresses-1]=Calloc((unsigned)1,(unsigned)dlen); ! 427: bcopy(cp,server[j].address[server[j].numAddresses-1],dlen); ! 428: break; ! 429: } ! 430: } ! 431: } ! 432: cp += dlen; ! 433: } ! 434: } ! 435: } ! 436: ! 437: /* ! 438: * If we are returning name server info, transfer it to ! 439: * the hostPtr. ! 440: * ! 441: */ ! 442: if (numServers > 0) { ! 443: hostPtr->servers = (ServerInfo **) Calloc((unsigned)numServers+1, ! 444: sizeof(ServerInfo *)); ! 445: for (i = 0; i < numServers; i++) { ! 446: hostPtr->servers[i] = (ServerInfo *) Calloc((unsigned)1, sizeof(ServerInfo)); ! 447: hostPtr->servers[i]->name = server[i].name; ! 448: ! 449: ! 450: hostPtr->servers[i]->domains = (char **) ! 451: Calloc((unsigned)server[i].numDomains+1,sizeof(char *)); ! 452: for (j = 0; j < server[i].numDomains; j++) { ! 453: hostPtr->servers[i]->domains[j] = server[i].domain[j]; ! 454: } ! 455: hostPtr->servers[i]->domains[j] = NULL; ! 456: ! 457: ! 458: hostPtr->servers[i]->addrList = (char **) ! 459: Calloc((unsigned)server[i].numAddresses+1,sizeof(char *)); ! 460: for (j = 0; j < server[i].numAddresses; j++) { ! 461: hostPtr->servers[i]->addrList[j] = server[i].address[j]; ! 462: } ! 463: hostPtr->servers[i]->addrList[j] = NULL; ! 464: ! 465: } ! 466: hostPtr->servers[i] = NULL; ! 467: } ! 468: ! 469: ! 470: if (queryType != T_A) { ! 471: return(SUCCESS); ! 472: } else { ! 473: return(NONAUTH); ! 474: } ! 475: } ! 476: ! 477: /* ! 478: ******************************************************************************* ! 479: * ! 480: * GetHostInfo -- ! 481: * ! 482: * Retrieves host name, address and alias information ! 483: * for a domain. ! 484: * ! 485: * Results: ! 486: * ERROR - res_mkquery failed. ! 487: * + return values from GetAnswer() ! 488: * ! 489: ******************************************************************************* ! 490: */ ! 491: ! 492: int ! 493: GetHostInfo(nsAddrPtr, queryClass, queryType, name, hostPtr, isserver) ! 494: struct in_addr *nsAddrPtr; ! 495: int queryClass; ! 496: int queryType; ! 497: char *name; ! 498: HostInfo *hostPtr; ! 499: int isserver; ! 500: { ! 501: int n; ! 502: int result; ! 503: register char *cp, **domain; ! 504: querybuf buf; ! 505: extern char *Calloc(), *hostalias(); ! 506: ! 507: /* catch explicit addresses */ ! 508: if (isdigit(*name) && (queryType == T_A)) { ! 509: long ina; ! 510: ! 511: ina = inet_addr(name); ! 512: ! 513: if (ina == -1) ! 514: return(ERROR); ! 515: ! 516: hostPtr->name = Calloc((unsigned)strlen(name)+3,1); ! 517: (void)sprintf(hostPtr->name,"[%s]",name); ! 518: hostPtr->aliases = 0; ! 519: hostPtr->servers = 0; ! 520: hostPtr->addrType = AF_INET; ! 521: hostPtr->addrLen = 4; ! 522: hostPtr->addrList = (char **)Calloc((unsigned)2,sizeof(char *)); ! 523: hostPtr->addrList[0] = Calloc(sizeof(long),sizeof(char)); ! 524: bcopy((char *)&ina,hostPtr->addrList[0],sizeof(ina)); ! 525: hostPtr->addrList[1] = 0; ! 526: ! 527: return(SUCCESS); ! 528: } ! 529: ! 530: for (cp = name, n = 0; *cp; cp++) ! 531: if (*cp == '.') ! 532: n++; ! 533: if ((n && *--cp == '.') || ! 534: (isserver == 0 && (_res.options & RES_DEFNAMES) == 0)) { ! 535: int defflag = _res.options & RES_DEFNAMES; ! 536: ! 537: _res.options &= ~RES_DEFNAMES; ! 538: if (n && *cp == '.') ! 539: *cp = 0; ! 540: result = GetHostDomain(nsAddrPtr, queryClass, queryType, ! 541: name, (char *)NULL, hostPtr, isserver); ! 542: if (n && *cp == 0) ! 543: *cp = '.'; ! 544: if (defflag) ! 545: _res.options |= RES_DEFNAMES; ! 546: return (result); ! 547: } ! 548: if (n == 0 && (cp = hostalias(name))) ! 549: return (GetHostDomain(nsAddrPtr, queryClass, queryType, ! 550: cp, (char *)NULL, hostPtr, isserver)); ! 551: for (domain = _res.dnsrch; *domain; domain++) { ! 552: result = GetHostDomain(nsAddrPtr, queryClass, queryType, ! 553: name, *domain, hostPtr, isserver); ! 554: if ((result != NXDOMAIN && result != NO_INFO) || ! 555: (_res.options & RES_DNSRCH) == 0) ! 556: return (result); ! 557: } ! 558: if (n) ! 559: return (GetHostDomain(nsAddrPtr, queryClass, queryType, ! 560: name, (char *)NULL, hostPtr, isserver)); ! 561: return (result); ! 562: } ! 563: ! 564: GetHostDomain(nsAddrPtr, queryClass, queryType, name, domain, hostPtr, isserver) ! 565: struct in_addr *nsAddrPtr; ! 566: int queryClass; ! 567: int queryType; ! 568: char *name, *domain; ! 569: HostInfo *hostPtr; ! 570: int isserver; ! 571: { ! 572: querybuf buf; ! 573: char nbuf[2*MAXDNAME+2]; ! 574: int n; ! 575: ! 576: if (domain) { ! 577: (void)sprintf(nbuf, "%.*s.%.*s", ! 578: MAXDNAME, name, MAXDNAME, domain); ! 579: name = nbuf; ! 580: } ! 581: n = res_mkquery(QUERY, name, queryClass, queryType, ! 582: (char *)0, 0, (char *)0, (char *) &buf, sizeof(buf)); ! 583: if (n < 0) { ! 584: if (_res.options & RES_DEBUG) { ! 585: printf("Res_mkquery failed\n"); ! 586: } ! 587: return (ERROR); ! 588: } ! 589: ! 590: n = GetAnswer(nsAddrPtr, queryType, (char *) &buf, n, 0, hostPtr, ! 591: isserver); ! 592: ! 593: /* ! 594: * GetAnswer didn't find a name, so set it to the specified one. ! 595: */ ! 596: if (n == NONAUTH) { ! 597: if (hostPtr->name == NULL) { ! 598: int len = strlen(name) + 1; ! 599: hostPtr->name = Calloc((unsigned)len, sizeof(char)); ! 600: bcopy(name, hostPtr->name, len); ! 601: } ! 602: } ! 603: return(n); ! 604: } ! 605: ! 606: ! 607: /* ! 608: ******************************************************************************* ! 609: * ! 610: * FindHostInfo -- ! 611: * ! 612: * Performs an inverse query to find the host name ! 613: * that corresponds to the given address. ! 614: * ! 615: * Results: ! 616: * ERROR - res_mkquery failed. ! 617: * + return values from GetAnswer() ! 618: * ! 619: ******************************************************************************* ! 620: */ ! 621: ! 622: int ! 623: FindHostInfo(nsAddrPtr, address, len, hostPtr) ! 624: struct in_addr *nsAddrPtr; ! 625: struct in_addr *address; ! 626: int len; ! 627: HostInfo *hostPtr; ! 628: { ! 629: int n; ! 630: querybuf buf; ! 631: ! 632: n = res_mkquery(IQUERY, (char *)0, C_IN, T_A, ! 633: (char *)address, len, (char *)0, (char *) &buf, sizeof(buf)); ! 634: if (n < 0) { ! 635: if (_res.options & RES_DEBUG) { ! 636: printf("Res_mkquery failed\n"); ! 637: } ! 638: return (ERROR); ! 639: } ! 640: return(GetAnswer(nsAddrPtr, T_A, (char *) &buf, n, 1, hostPtr, 1)); ! 641: } ! 642: ! 643: /* ! 644: ******************************************************************************* ! 645: * ! 646: * FreeHostInfoPtr -- ! 647: * ! 648: * Deallocates all the calloc'd areas for a HostInfo ! 649: * variable. ! 650: * ! 651: ******************************************************************************* ! 652: */ ! 653: ! 654: void ! 655: FreeHostInfoPtr(hostPtr) ! 656: HostInfo *hostPtr; ! 657: { ! 658: int i, j; ! 659: ! 660: if (hostPtr->name != NULL) { ! 661: free(hostPtr->name); ! 662: hostPtr->name = NULL; ! 663: } ! 664: ! 665: if (hostPtr->aliases != NULL) { ! 666: i = 0; ! 667: while (hostPtr->aliases[i] != NULL) { ! 668: free(hostPtr->aliases[i]); ! 669: i++; ! 670: } ! 671: free((char *)hostPtr->aliases); ! 672: hostPtr->aliases = NULL; ! 673: } ! 674: ! 675: if (hostPtr->addrList != NULL) { ! 676: i = 0; ! 677: while (hostPtr->addrList[i] != NULL) { ! 678: free(hostPtr->addrList[i]); ! 679: i++; ! 680: } ! 681: free((char *)hostPtr->addrList); ! 682: hostPtr->addrList = NULL; ! 683: } ! 684: ! 685: if (hostPtr->servers != NULL) { ! 686: i = 0; ! 687: while (hostPtr->servers[i] != NULL) { ! 688: ! 689: if (hostPtr->servers[i]->name != NULL) { ! 690: free(hostPtr->servers[i]->name); ! 691: } ! 692: ! 693: if (hostPtr->servers[i]->domains != NULL) { ! 694: j = 0; ! 695: while (hostPtr->servers[i]->domains[j] != NULL) { ! 696: free(hostPtr->servers[i]->domains[j]); ! 697: j++; ! 698: } ! 699: free((char *)hostPtr->servers[i]->domains); ! 700: } ! 701: ! 702: if (hostPtr->servers[i]->addrList != NULL) { ! 703: j = 0; ! 704: while (hostPtr->servers[i]->addrList[j] != NULL) { ! 705: free(hostPtr->servers[i]->addrList[j]); ! 706: j++; ! 707: } ! 708: free((char *)hostPtr->servers[i]->addrList); ! 709: } ! 710: free((char *)hostPtr->servers[i]); ! 711: i++; ! 712: } ! 713: free((char *)hostPtr->servers); ! 714: hostPtr->servers = NULL; ! 715: } ! 716: } ! 717: ! 718: /* ! 719: ******************************************************************************* ! 720: * ! 721: * GetHostList -- ! 722: * ! 723: * Performs a completion query when given an incomplete ! 724: * name. ! 725: * ! 726: * Still under development. ! 727: * ! 728: ******************************************************************************* ! 729: */ ! 730: ! 731: #if notdef ! 732: ! 733: int ! 734: GetHostList(nsAddrPtr, queryType, name, defaultName, hostPtr) ! 735: struct in_addr *nsAddrPtr; ! 736: int queryType; ! 737: char *name, *defaultName; ! 738: HostInfo *hostPtr; ! 739: { ! 740: int n; ! 741: querybuf buf; ! 742: ! 743: n = res_mkquery(CQUERYM, name, C_IN, T_A, defaultName, 0, (char *)0, ! 744: (char *) &buf, sizeof(buf)); ! 745: if (n < 0) { ! 746: if (_res.options & RES_DEBUG) ! 747: printf("Res_mkquery failed\n"); ! 748: return (ERROR); ! 749: } ! 750: return(GetAnswer(nsAddrPtr, queryType, (char *)&buf, n, 0, hostPtr, 1)); ! 751: } ! 752: #endif notdef
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.