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