![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ns_resp.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|
Return to ns_resp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named |
1.1 ! root 1: /* ! 2: * Copyright (c) 1986, 1988, 1990 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: static char sccsid[] = "@(#)ns_resp.c 4.63 (Berkeley) 6/1/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #include <stdio.h> ! 25: #include <sys/param.h> ! 26: #include <sys/time.h> ! 27: #include <sys/socket.h> ! 28: #include <sys/file.h> ! 29: #include <netinet/in.h> ! 30: #include <syslog.h> ! 31: #include <arpa/nameser.h> ! 32: #include "ns.h" ! 33: #include "db.h" ! 34: ! 35: extern int debug; ! 36: extern FILE *ddt; ! 37: extern int errno; ! 38: extern u_char *dnptrs[]; ! 39: extern time_t retrytime(); ! 40: extern struct fwdinfo *fwdtab; ! 41: extern struct sockaddr_in from_addr; /* Source addr of last packet */ ! 42: extern int needs_prime_cache; ! 43: extern int priming; ! 44: ! 45: struct qinfo *sysquery(); ! 46: ! 47: ns_resp(msg, msglen) ! 48: u_char *msg; ! 49: int msglen; ! 50: { ! 51: register struct qinfo *qp; ! 52: register HEADER *hp; ! 53: register struct qserv *qs; ! 54: register struct databuf *ns, *ns2; ! 55: register u_char *cp; ! 56: struct databuf *nsp[NSMAX], **nspp; ! 57: int i, c, n, ancount, aucount, nscount, arcount; ! 58: int type, class, dbflags; ! 59: int cname = 0; /* flag for processing cname response */ ! 60: int count, founddata, foundname; ! 61: int buflen; ! 62: int newmsglen; ! 63: char name[MAXDNAME], *dname; ! 64: char *fname; ! 65: u_char newmsg[BUFSIZ]; ! 66: u_char **dpp, *tp; ! 67: time_t rtrip; ! 68: ! 69: struct hashbuf *htp; ! 70: struct namebuf *np; ! 71: struct netinfo *lp; ! 72: extern struct netinfo *local(); ! 73: extern int nsid; ! 74: extern int addcount; ! 75: struct fwdinfo *fwd; ! 76: ! 77: #ifdef STATS ! 78: stats[S_RESPONSES].cnt++; ! 79: #endif ! 80: hp = (HEADER *) msg; ! 81: if ((qp = qfindid(hp->id)) == NULL ) { ! 82: #ifdef DEBUG ! 83: if (debug > 1) ! 84: fprintf(ddt,"DUP? dropped (id %d)\n", ntohs(hp->id)); ! 85: #endif ! 86: #ifdef STATS ! 87: stats[S_DUPRESP].cnt++; ! 88: #endif ! 89: return; ! 90: } ! 91: ! 92: #ifdef DEBUG ! 93: if (debug >= 2) ! 94: fprintf(ddt,"%s response nsid=%d id=%d\n", ! 95: qp->q_system ? "SYSTEM" : "USER", ! 96: ntohs(qp->q_nsid), ntohs(qp->q_id)); ! 97: #endif ! 98: ! 99: /* ! 100: * Here we handle bad responses from servers. ! 101: * Several possibilities come to mind: ! 102: * The server is sick and returns SERVFAIL ! 103: * The server returns some garbage opcode (its sick) ! 104: * The server can't understand our query and return FORMERR ! 105: * In all these cases, we simply drop the packet and force ! 106: * a retry. This will make him look bad due to unresponsiveness. ! 107: * Be sure not to include authoritative NXDOMAIN ! 108: */ ! 109: if ((hp->rcode != NOERROR && hp->rcode != NXDOMAIN) ! 110: || (hp->rcode == NXDOMAIN && !hp->aa) ! 111: || hp->opcode != QUERY) { ! 112: #ifdef DEBUG ! 113: if (debug >= 2) ! 114: fprintf(ddt,"resp: error (ret %d, op %d), dropped\n", ! 115: hp->rcode, hp->opcode); ! 116: #endif ! 117: #ifdef STATS ! 118: stats[S_BADRESPONSES].cnt++; ! 119: #endif ! 120: return; ! 121: } ! 122: ! 123: #ifdef ALLOW_UPDATES ! 124: if ( (hp->rcode == NOERROR) && ! 125: (hp->opcode == UPDATEA || hp->opcode == UPDATED || ! 126: hp->opcode == UPDATEDA || hp->opcode == UPDATEM || ! 127: hp->opcode == UPDATEMA) ) { ! 128: /* ! 129: * Update the secondary's copy, now that the primary ! 130: * successfully completed the update. Zone doesn't matter ! 131: * for dyn. update -- doupdate calls findzone to find it ! 132: */ ! 133: doupdate(qp->q_msg, qp->q_msglen, qp->q_msg + sizeof(HEADER), ! 134: 0, (struct databuf *)0, 0); ! 135: #ifdef DEBUG ! 136: if (debug >= 3) ! 137: fprintf(ddt,"resp: leaving, UPDATE*\n"); ! 138: #endif ! 139: /* return code filled in by doupdate */ ! 140: goto return_msg; ! 141: } ! 142: #endif ALLOW_UPDATES ! 143: ! 144: /* ! 145: * Determine if the response came from a forwarder. Packets from ! 146: * anyplace not listed as a forwarder or as a server to whom we ! 147: * might have forwarded the query will be dropped. ! 148: */ ! 149: for (fwd = fwdtab; fwd != (struct fwdinfo *)NULL; fwd = fwd->next) ! 150: if (bcmp((char *)&fwd->fwdaddr.sin_addr, &from_addr.sin_addr, ! 151: sizeof(struct in_addr)) == 0) ! 152: break; ! 153: /* ! 154: * If we were using nameservers, find the qinfo pointer and update ! 155: * the rtt and fact that we have called on this server before. ! 156: */ ! 157: if (fwd == (struct fwdinfo *)NULL) { ! 158: struct timeval *stp; ! 159: ! 160: for (n = 0, qs = qp->q_addr; n < qp->q_naddr; n++, qs++) ! 161: if (bcmp((char *)&qs->ns_addr.sin_addr, ! 162: &from_addr.sin_addr, sizeof(struct in_addr)) == 0) ! 163: break; ! 164: if (n >= qp->q_naddr) { ! 165: #ifdef DEBUG ! 166: if (debug) ! 167: fprintf(ddt, "Response from unexpected source %s\n", ! 168: inet_ntoa(from_addr.sin_addr)); ! 169: #endif DEBUG ! 170: #ifdef STATS ! 171: stats[S_MARTIANS].cnt++; ! 172: #endif ! 173: /* ! 174: * We don't know who this response came from so it ! 175: * gets dropped on the floor. ! 176: */ ! 177: return; ! 178: } ! 179: stp = &qs->stime; ! 180: ! 181: /* Handle response from different (untried) interface */ ! 182: if (stp->tv_sec == 0) { ! 183: ns = qs->ns; ! 184: while (qs > qp->q_addr && ! 185: (qs->stime.tv_sec == 0 || qs->ns != ns)) ! 186: qs--; ! 187: *stp = qs->stime; ! 188: #ifdef DEBUG ! 189: if (debug) ! 190: fprintf(ddt, ! 191: "Response from unused address %s, assuming %s\n", ! 192: inet_ntoa(from_addr.sin_addr), ! 193: inet_ntoa(qs->ns_addr.sin_addr)); ! 194: #endif DEBUG ! 195: } ! 196: ! 197: /* compute query round trip time */ ! 198: rtrip = ((tt.tv_sec - stp->tv_sec) * 1000 + ! 199: (tt.tv_usec - stp->tv_usec) / 1000); ! 200: ! 201: #ifdef DEBUG ! 202: if (debug > 2) ! 203: fprintf(ddt,"stime %d/%d now %d/%d rtt %d\n", ! 204: stp->tv_sec, stp->tv_usec, ! 205: tt.tv_sec, tt.tv_usec, rtrip); ! 206: #endif ! 207: /* prevent floating point overflow, limit to 1000 sec */ ! 208: if (rtrip > 1000000) ! 209: rtrip = 1000000; ! 210: ns = qs->nsdata; ! 211: /* ! 212: * Don't update nstime if this doesn't look ! 213: * like an address databuf now. XXX ! 214: */ ! 215: if (ns->d_type == T_A && ns->d_class == qs->ns->d_class) { ! 216: if (ns->d_nstime == 0) ! 217: ns->d_nstime = (u_long)rtrip; ! 218: else ! 219: ns->d_nstime = ns->d_nstime * ALPHA + ! 220: (1-ALPHA) * (u_long)rtrip; ! 221: /* prevent floating point overflow, limit to 1000 sec */ ! 222: if (ns->d_nstime > 1000000) ! 223: ns->d_nstime = 1000000; ! 224: } ! 225: ! 226: /* ! 227: * Record the source so that we do not use this NS again. ! 228: */ ! 229: if(qp->q_nusedns < NSMAX) { ! 230: qp->q_usedns[qp->q_nusedns++] = qs->ns; ! 231: #ifdef DEBUG ! 232: if(debug > 1) ! 233: fprintf(ddt, "NS #%d addr %s used, rtt %d\n", ! 234: n, inet_ntoa(qs->ns_addr.sin_addr), ! 235: ns->d_nstime); ! 236: #endif DEBUG ! 237: } ! 238: ! 239: /* ! 240: * Penalize those who had earlier chances but failed ! 241: * by multiplying round-trip times by BETA (>1). ! 242: * Improve nstime for unused addresses by applying GAMMA. ! 243: * The GAMMA factor makes unused entries slowly ! 244: * improve, so they eventually get tried again. ! 245: * GAMMA should be slightly less than 1. ! 246: * Watch out for records that may have timed out ! 247: * and are no longer the correct type. XXX ! 248: */ ! 249: ! 250: for (n = 0, qs = qp->q_addr; n < qp->q_naddr; n++, qs++) { ! 251: ns2 = qs->nsdata; ! 252: if (ns2 == ns) ! 253: continue; ! 254: if (ns2->d_type != T_A || ! 255: ns2->d_class != qs->ns->d_class) /* XXX */ ! 256: continue; ! 257: if (qs->stime.tv_sec) { ! 258: if (ns2->d_nstime == 0) ! 259: ns2->d_nstime = rtrip * BETA; ! 260: else ! 261: ns2->d_nstime = ! 262: ns2->d_nstime * BETA + (1-ALPHA) * rtrip; ! 263: if (ns2->d_nstime > 1000000) ! 264: ns2->d_nstime = 1000000; ! 265: } else ! 266: ns2->d_nstime = ns2->d_nstime * GAMMA; ! 267: #ifdef DEBUG ! 268: if(debug > 1) ! 269: fprintf(ddt, "NS #%d %s rtt now %d\n", n, ! 270: inet_ntoa(qs->ns_addr.sin_addr), ! 271: ns2->d_nstime); ! 272: #endif DEBUG ! 273: } ! 274: } ! 275: ! 276: /* ! 277: * Skip query section ! 278: */ ! 279: addcount = 0; ! 280: cp = msg + sizeof(HEADER); ! 281: dpp = dnptrs; ! 282: *dpp++ = msg; ! 283: if ((*cp & INDIR_MASK) == 0) ! 284: *dpp++ = cp; ! 285: *dpp = NULL; ! 286: if (hp->qdcount) { ! 287: n = dn_skipname(cp, msg + msglen); ! 288: if (n <= 0) ! 289: goto formerr; ! 290: cp += n; ! 291: GETSHORT(type, cp); ! 292: GETSHORT(class, cp); ! 293: if (cp - msg > msglen) ! 294: goto formerr; ! 295: } ! 296: ! 297: /* ! 298: * Save answers, authority, and additional records for future use. ! 299: */ ! 300: ancount = ntohs(hp->ancount); ! 301: aucount = ntohs(hp->nscount); ! 302: arcount = ntohs(hp->arcount); ! 303: nscount = 0; ! 304: tp = cp; ! 305: #ifdef DEBUG ! 306: if (debug >= 3) ! 307: fprintf(ddt,"resp: ancount %d, aucount %d, arcount %d\n", ! 308: ancount, aucount, arcount); ! 309: #endif ! 310: ! 311: /* ! 312: * If there's an answer, check if it's a CNAME response; ! 313: * if no answer but aucount > 0, see if there is an NS ! 314: * or just an SOA. (NOTE: ancount might be 1 with a CNAME, ! 315: * and NS records may still be in the authority section; ! 316: * we don't bother counting them, as we only use nscount ! 317: * if ancount == 0.) ! 318: */ ! 319: if (ancount == 1 || (ancount == 0 && aucount > 0)) { ! 320: c = aucount; ! 321: do { ! 322: if (tp - msg >= msglen) ! 323: goto formerr; ! 324: n = dn_skipname(tp, msg + msglen); ! 325: if (n <= 0) ! 326: goto formerr; ! 327: tp += n; /* name */ ! 328: GETSHORT(i, tp); /* type */ ! 329: tp += sizeof(u_short); /* class */ ! 330: tp += sizeof(u_long); /* ttl */ ! 331: GETSHORT(count, tp); /* dlen */ ! 332: if (tp - msg > msglen - count) ! 333: goto formerr; ! 334: tp += count; ! 335: if (ancount && i == T_CNAME) { ! 336: cname++; ! 337: #ifdef DEBUG ! 338: if (debug) ! 339: fprintf(ddt,"CNAME - needs more processing\n"); ! 340: #endif ! 341: if (!qp->q_cmsglen) { ! 342: qp->q_cmsg = qp->q_msg; ! 343: qp->q_cmsglen = qp->q_msglen; ! 344: qp->q_msg = NULL; ! 345: qp->q_msglen = 0; ! 346: } ! 347: } ! 348: /* ! 349: * See if authority record is a nameserver. ! 350: */ ! 351: if (ancount == 0 && i == T_NS) ! 352: nscount++; ! 353: } while (--c > 0); ! 354: tp = cp; ! 355: } ! 356: ! 357: /* ! 358: * Add the info received in the response to the Data Base ! 359: */ ! 360: c = ancount + aucount + arcount; ! 361: #ifdef notdef ! 362: /* ! 363: * If the request was for a CNAME that doesn't exist, ! 364: * but the name is valid, fetch any other data for the name. ! 365: * DON'T do this now, as it will requery if data are already ! 366: * in the cache (maybe later with negative caching). ! 367: */ ! 368: if (hp->qdcount && type == T_CNAME && c == 0 && hp->rcode == NOERROR && ! 369: !qp->q_system) { ! 370: #ifdef DEBUG ! 371: if (debug >= 3) ! 372: fprintf(ddt,"resp: leaving, no CNAME\n"); ! 373: #endif ! 374: /* Cause us to put it in the cache later */ ! 375: prime(class, T_ANY, qp); ! 376: ! 377: /* Nothing to store, just give user the answer */ ! 378: goto return_msg; ! 379: } ! 380: #endif /* notdef */ ! 381: ! 382: nspp = nsp; ! 383: if (qp->q_system) ! 384: dbflags = DB_NOTAUTH | DB_NODATA; ! 385: else ! 386: dbflags = DB_NOTAUTH | DB_NODATA | DB_NOHINTS; ! 387: for (i = 0; i < c; i++) { ! 388: struct databuf *ns3; ! 389: ! 390: if (cp >= msg + msglen) ! 391: goto formerr; ! 392: ns3 = 0; ! 393: if ((n = doupdate(msg, msglen, cp, 0, &ns3, dbflags)) < 0) { ! 394: #ifdef DEBUG ! 395: if (debug) ! 396: fprintf(ddt,"resp: leaving, doupdate failed\n"); ! 397: #endif ! 398: /* return code filled in by doupdate */ ! 399: goto return_msg; ! 400: } ! 401: /* ! 402: * Remember nameservers from the authority section ! 403: * for referrals. ! 404: * (This is usually overwritten by findns below(?). XXX ! 405: */ ! 406: if (ns3 && i >= ancount && i < ancount + aucount && ! 407: nspp < &nsp[NSMAX-1]) ! 408: *nspp++ = ns3; ! 409: cp += n; ! 410: } ! 411: ! 412: if (qp->q_system && ancount) { ! 413: if (qp->q_system == PRIMING_CACHE) ! 414: check_root(); ! 415: #ifdef DEBUG ! 416: if (debug > 2) ! 417: fprintf(ddt,"resp: leaving, SYSQUERY ancount %d\n", ancount); ! 418: #endif ! 419: qremove(qp); ! 420: return; ! 421: } ! 422: ! 423: if (cp > msg + msglen) ! 424: goto formerr; ! 425: ! 426: /* ! 427: * If there are addresses and this is a local query, ! 428: * sort them appropriately for the local context. ! 429: */ ! 430: if (ancount > 1 && (lp = local(&qp->q_from)) != NULL) ! 431: sort_response(tp, ancount, lp, msg + msglen); ! 432: ! 433: /* ! 434: * An answer to a T_ANY query or a successful answer to a ! 435: * regular query with no indirection, then just return answer. ! 436: */ ! 437: if ((hp->qdcount && type == T_ANY && ancount) || ! 438: (!cname && !qp->q_cmsglen && ancount)) { ! 439: #ifdef DEBUG ! 440: if (debug >= 3) ! 441: fprintf(ddt,"resp: got as much answer as there is\n"); ! 442: #endif ! 443: goto return_msg; ! 444: } ! 445: ! 446: /* ! 447: * Eventually we will want to cache this negative answer. ! 448: */ ! 449: if (ancount == 0 && nscount == 0 && ! 450: (hp->aa || fwd || class == C_ANY)) { ! 451: /* We have an authoritative NO */ ! 452: #ifdef DEBUG ! 453: if (debug >= 3) ! 454: fprintf(ddt,"resp: leaving auth NO\n"); ! 455: #endif ! 456: if (qp->q_cmsglen) { ! 457: msg = (u_char *)qp->q_cmsg; ! 458: msglen = qp->q_cmsglen; ! 459: hp = (HEADER *)msg; ! 460: } ! 461: goto return_msg; ! 462: } ! 463: ! 464: /* ! 465: * All messages in here need further processing. i.e. they ! 466: * are either CNAMEs or we got referred again. ! 467: */ ! 468: count = 0; ! 469: founddata = 0; ! 470: foundname = 0; ! 471: dname = name; ! 472: if (!cname && qp->q_cmsglen && ancount) { ! 473: #ifdef DEBUG ! 474: if (debug) ! 475: fprintf(ddt,"Cname second pass\n"); ! 476: #endif ! 477: newmsglen = qp->q_cmsglen; ! 478: bcopy(qp->q_cmsg, newmsg, newmsglen); ! 479: } else { ! 480: newmsglen = msglen; ! 481: bcopy(msg, newmsg, newmsglen); ! 482: } ! 483: hp = (HEADER *) newmsg; ! 484: hp->ancount = 0; ! 485: hp->nscount = 0; ! 486: hp->arcount = 0; ! 487: dnptrs[0] = newmsg; ! 488: dnptrs[1] = NULL; ! 489: cp = newmsg + sizeof(HEADER); ! 490: if (cname) ! 491: cp += dn_skipname(cp, newmsg + newmsglen) + QFIXEDSZ; ! 492: if ((n = dn_expand(newmsg, newmsg + newmsglen, ! 493: cp, dname, sizeof(name))) < 0) { ! 494: #ifdef DEBUG ! 495: if (debug) ! 496: fprintf(ddt,"dn_expand failed\n" ); ! 497: #endif ! 498: goto servfail; ! 499: } ! 500: if (!cname) ! 501: cp += n + QFIXEDSZ; ! 502: buflen = sizeof(newmsg) - (cp - newmsg); ! 503: ! 504: try_again: ! 505: #ifdef DEBUG ! 506: if (debug) ! 507: fprintf(ddt,"resp: nlookup(%s) type=%d\n",dname, type); ! 508: #endif ! 509: fname = ""; ! 510: htp = hashtab; /* lookup relative to root */ ! 511: np = nlookup(dname, &htp, &fname, 0); ! 512: #ifdef DEBUG ! 513: if (debug) ! 514: fprintf(ddt,"resp: %s '%s' as '%s' (cname=%d)\n", ! 515: np == NULL ? "missed" : "found", dname, fname, cname); ! 516: #endif ! 517: if (np == NULL || fname != dname) ! 518: goto fetch_ns; ! 519: ! 520: foundname++; ! 521: count = cp - newmsg; ! 522: n = finddata(np, class, type, hp, &dname, &buflen, &count); ! 523: if (n == 0) ! 524: goto fetch_ns; /* NO data available */ ! 525: cp += n; ! 526: buflen -= n; ! 527: hp->ancount += count; ! 528: if (fname != dname && type != T_CNAME && type != T_ANY) { ! 529: cname++; ! 530: goto try_again; ! 531: } ! 532: founddata = 1; ! 533: ! 534: #ifdef DEBUG ! 535: if (debug >= 3) { ! 536: fprintf(ddt,"resp: foundname = %d count = %d ", foundname, count); ! 537: fprintf(ddt,"founddata = %d cname = %d\n", founddata, cname); ! 538: } ! 539: #endif ! 540: ! 541: fetch_ns: ! 542: hp->ancount = htons(hp->ancount); ! 543: /* ! 544: * Look for name servers to refer to and fill in the authority ! 545: * section or record the address for forwarding the query ! 546: * (recursion desired). ! 547: */ ! 548: switch (findns(&np, class, nsp, &count)) { ! 549: case NXDOMAIN: /* shouldn't happen */ ! 550: #ifdef DEBUG ! 551: if (debug >= 3) ! 552: fprintf(ddt,"req: leaving (%s, rcode %d)\n", ! 553: dname, hp->rcode); ! 554: #endif ! 555: if (!foundname) ! 556: hp->rcode = NXDOMAIN; ! 557: if (class != C_ANY) { ! 558: hp->aa = 1; ! 559: /* ! 560: * should return SOA if founddata == 0, ! 561: * but old named's are confused by an SOA ! 562: * in the auth. section if there's no error. ! 563: */ ! 564: if (foundname == 0 && np) { ! 565: n = doaddauth(hp, cp, buflen, np, nsp[0]); ! 566: cp += n; ! 567: buflen -= n; ! 568: } ! 569: } ! 570: goto return_newmsg; ! 571: ! 572: case SERVFAIL: ! 573: goto servfail; ! 574: } ! 575: ! 576: if (founddata) { ! 577: hp = (HEADER *)newmsg; ! 578: n = add_data(np, nsp, cp, buflen); ! 579: if (n < 0) { ! 580: hp->tc = 1; ! 581: n = (-n); ! 582: } ! 583: cp += n; ! 584: buflen -= n; ! 585: hp->nscount = htons((u_short)count); ! 586: goto return_newmsg; ! 587: } ! 588: ! 589: /* ! 590: * If we get here, we don't have the answer yet and are about ! 591: * to iterate to try and get it. First, infinite loop avoidance. ! 592: */ ! 593: if (qp->q_nqueries++ > MAXQUERIES) { ! 594: #ifdef DEBUG ! 595: if (debug) ! 596: fprintf(ddt,"resp: MAXQUERIES exceeded (%s, class %d, type %d)\n", ! 597: dname, class, type); ! 598: #endif ! 599: syslog(LOG_NOTICE, ! 600: "MAXQUERIES exceeded, possible data loop in resolving (%s)", ! 601: dname); ! 602: goto servfail; ! 603: } ! 604: ! 605: /* Reset the query control structure */ ! 606: qp->q_naddr = 0; ! 607: qp->q_curaddr = 0; ! 608: qp->q_fwd = fwdtab; ! 609: if (nslookup(nsp, qp) == 0) { ! 610: #ifdef DEBUG ! 611: if (debug >= 3) ! 612: fprintf(ddt,"resp: no addrs found for NS's\n"); ! 613: #endif ! 614: goto servfail; ! 615: } ! 616: for (n = 0; n < qp->q_naddr; n++) ! 617: qp->q_addr[n].stime.tv_sec = 0; ! 618: if (!qp->q_fwd) ! 619: qp->q_addr[0].stime = tt; ! 620: if (cname) { ! 621: if (qp->q_cname++ == MAXCNAMES) { ! 622: #ifdef DEBUG ! 623: if (debug >= 3) ! 624: fprintf(ddt,"resp: leaving, MAXCNAMES exceeded\n"); ! 625: #endif ! 626: goto servfail; ! 627: } ! 628: #ifdef DEBUG ! 629: if (debug) ! 630: fprintf(ddt,"q_cname = %d\n",qp->q_cname); ! 631: if (debug >= 3) ! 632: fprintf(ddt,"resp: building recursive query; nslookup\n"); ! 633: #endif ! 634: if (qp->q_msg) ! 635: (void) free(qp->q_msg); ! 636: if ((qp->q_msg = malloc(BUFSIZ)) == NULL) { ! 637: #ifdef DEBUG ! 638: if (debug) ! 639: fprintf(ddt,"resp: malloc error\n"); ! 640: #endif ! 641: goto servfail; ! 642: } ! 643: qp->q_msglen = res_mkquery(QUERY, dname, class, ! 644: type, (char *)NULL, 0, NULL, qp->q_msg, BUFSIZ); ! 645: hp = (HEADER *) qp->q_msg; ! 646: hp->rd = 0; ! 647: } else ! 648: hp = (HEADER *)qp->q_msg; ! 649: hp->id = qp->q_nsid = htons((u_short)++nsid); ! 650: if (qp->q_fwd) ! 651: hp->rd = 1; ! 652: unsched(qp); ! 653: schedretry(qp, retrytime(qp)); ! 654: #ifdef DEBUG ! 655: if (debug) ! 656: fprintf(ddt,"resp: forw -> %s %d (%d) nsid=%d id=%d %dms\n", ! 657: inet_ntoa(Q_NEXTADDR(qp,0)->sin_addr), ! 658: ds, ntohs(Q_NEXTADDR(qp,0)->sin_port), ! 659: ntohs(qp->q_nsid), ntohs(qp->q_id), ! 660: qp->q_addr[0].nsdata->d_nstime); ! 661: if ( debug >= 10) ! 662: fp_query(msg, ddt); ! 663: #endif ! 664: if (sendto(ds, qp->q_msg, qp->q_msglen, 0, ! 665: (struct sockaddr *)Q_NEXTADDR(qp,0), ! 666: sizeof(struct sockaddr_in)) < 0) { ! 667: #ifdef DEBUG ! 668: if (debug >= 5) ! 669: fprintf(ddt, "sendto error = %d\n", errno); ! 670: #endif ! 671: } ! 672: hp->rd = 0; /* leave set to 0 for dup detection */ ! 673: #ifdef STATS ! 674: stats[S_OUTPKTS].cnt++; ! 675: #endif ! 676: #ifdef DEBUG ! 677: if (debug >= 3) ! 678: fprintf(ddt,"resp: Query sent.\n"); ! 679: #endif ! 680: return; ! 681: ! 682: formerr: ! 683: #ifdef DEBUG ! 684: if (debug) ! 685: fprintf(ddt,"FORMERR resp() from %s size err %d, msglen %d\n", ! 686: inet_ntoa(from_addr.sin_addr), ! 687: cp-msg, msglen); ! 688: #endif ! 689: syslog(LOG_INFO, "Malformed response from %s\n", ! 690: inet_ntoa(from_addr.sin_addr)); ! 691: #ifdef STATS ! 692: stats[S_RESPFORMERR].cnt++; ! 693: #endif ! 694: return; ! 695: ! 696: return_msg: ! 697: #ifdef STATS ! 698: stats[S_RESPOK].cnt++; ! 699: #endif ! 700: /* The "standard" return code */ ! 701: hp->qr = 1; ! 702: hp->id = qp->q_id; ! 703: hp->rd = 1; ! 704: hp->ra = 1; ! 705: (void) send_msg(msg, msglen, qp); ! 706: qremove(qp); ! 707: return; ! 708: ! 709: return_newmsg: ! 710: #ifdef STATS ! 711: stats[S_RESPOK].cnt++; ! 712: #endif ! 713: if (addcount) { ! 714: n = doaddinfo(hp, cp, buflen); ! 715: cp += n; ! 716: buflen -= n; ! 717: } ! 718: ! 719: hp->id = qp->q_id; ! 720: hp->rd = 1; ! 721: hp->ra = 1; ! 722: hp->qr = 1; ! 723: (void) send_msg(newmsg, cp - newmsg, qp); ! 724: qremove(qp); ! 725: return; ! 726: ! 727: servfail: ! 728: #ifdef STATS ! 729: stats[S_RESPFAIL].cnt++; ! 730: #endif ! 731: hp = (HEADER *)(cname ? qp->q_cmsg : qp->q_msg); ! 732: hp->rcode = SERVFAIL; ! 733: hp->id = qp->q_id; ! 734: hp->rd = 1; ! 735: hp->ra = 1; ! 736: hp->qr = 1; ! 737: (void) send_msg((char *)hp, (cname ? qp->q_cmsglen : qp->q_msglen), qp); ! 738: qremove(qp); ! 739: return; ! 740: } ! 741: ! 742: /* ! 743: * Decode the resource record 'rrp' and update the database. ! 744: * If savens is true, record pointer for forwarding queries a second time. ! 745: */ ! 746: doupdate(msg, msglen, rrp, zone, savens, flags) ! 747: char *msg; ! 748: u_char *rrp; ! 749: struct databuf **savens; ! 750: int msglen, zone, flags; ! 751: { ! 752: register u_char *cp; ! 753: register int n; ! 754: int class, type, dlen, n1; ! 755: u_long ttl; ! 756: struct databuf *dp; ! 757: char dname[MAXDNAME]; ! 758: u_char *cp1; ! 759: u_char data[BUFSIZ]; ! 760: register HEADER *hp = (HEADER *) msg; ! 761: #ifdef ALLOW_UPDATES ! 762: int zonenum; ! 763: #endif ! 764: ! 765: #ifdef DEBUG ! 766: if (debug > 2) ! 767: fprintf(ddt,"doupdate(zone %d, savens %x, flags %x)\n", ! 768: zone, savens, flags); ! 769: #endif ! 770: ! 771: cp = rrp; ! 772: if ((n = dn_expand(msg, msg + msglen, cp, dname, sizeof(dname))) < 0) { ! 773: hp->rcode = FORMERR; ! 774: return (-1); ! 775: } ! 776: cp += n; ! 777: GETSHORT(type, cp); ! 778: GETSHORT(class, cp); ! 779: GETLONG(ttl, cp); ! 780: GETSHORT(dlen, cp); ! 781: #ifdef DEBUG ! 782: if (debug > 2) ! 783: fprintf(ddt,"doupdate: dname %s type %d class %d ttl %d\n", ! 784: dname, type, class, ttl); ! 785: #endif ! 786: /* ! 787: * Convert the resource record data into the internal ! 788: * database format. ! 789: */ ! 790: switch (type) { ! 791: case T_A: ! 792: case T_WKS: ! 793: case T_HINFO: ! 794: case T_UINFO: ! 795: case T_UID: ! 796: case T_GID: ! 797: case T_TXT: ! 798: #ifdef ALLOW_T_UNSPEC ! 799: case T_UNSPEC: ! 800: #endif ALLOW_T_UNSPEC ! 801: cp1 = cp; ! 802: n = dlen; ! 803: cp += n; ! 804: break; ! 805: ! 806: case T_CNAME: ! 807: case T_MB: ! 808: case T_MG: ! 809: case T_MR: ! 810: case T_NS: ! 811: case T_PTR: ! 812: if ((n = dn_expand(msg, msg + msglen, cp, data, ! 813: sizeof(data))) < 0) { ! 814: hp->rcode = FORMERR; ! 815: return (-1); ! 816: } ! 817: cp += n; ! 818: cp1 = data; ! 819: n = strlen(data) + 1; ! 820: break; ! 821: ! 822: case T_MINFO: ! 823: case T_SOA: ! 824: if ((n = dn_expand(msg, msg + msglen, cp, data, ! 825: sizeof(data))) < 0) { ! 826: hp->rcode = FORMERR; ! 827: return (-1); ! 828: } ! 829: cp += n; ! 830: cp1 = data + (n = strlen(data) + 1); ! 831: n1 = sizeof(data) - n; ! 832: if (type == T_SOA) ! 833: n1 -= 5 * sizeof(u_long); ! 834: if ((n = dn_expand(msg, msg + msglen, cp, cp1, n1)) < 0) { ! 835: hp->rcode = FORMERR; ! 836: return (-1); ! 837: } ! 838: cp += n; ! 839: cp1 += strlen(cp1) + 1; ! 840: if (type == T_SOA) { ! 841: bcopy(cp, cp1, n = 5 * sizeof(u_long)); ! 842: cp += n; ! 843: cp1 += n; ! 844: } ! 845: n = cp1 - data; ! 846: cp1 = data; ! 847: break; ! 848: ! 849: case T_MX: ! 850: /* grab preference */ ! 851: bcopy(cp,data,sizeof(u_short)); ! 852: cp1 = data + sizeof(u_short); ! 853: cp += sizeof(u_short); ! 854: ! 855: /* get name */ ! 856: if ((n = dn_expand(msg, msg + msglen, cp, cp1, ! 857: sizeof(data)-sizeof(u_short))) < 0) ! 858: return(-1); ! 859: cp += n; ! 860: ! 861: /* compute end of data */ ! 862: cp1 += strlen(cp1) + 1; ! 863: /* compute size of data */ ! 864: n = cp1 - data; ! 865: cp1 = data; ! 866: break; ! 867: ! 868: default: ! 869: #ifdef DEBUG ! 870: if (debug >= 3) ! 871: fprintf(ddt,"unknown type %d\n", type); ! 872: #endif ! 873: return ((cp - rrp) + dlen); ! 874: } ! 875: if (n > MAXDATA) { ! 876: #ifdef DEBUG ! 877: if (debug) ! 878: fprintf(ddt, ! 879: "update type %d: %d bytes is too much data\n", ! 880: type, n); ! 881: #endif ! 882: hp->rcode = NOCHANGE; /* XXX - FORMERR ??? */ ! 883: return(-1); ! 884: } ! 885: ! 886: #ifdef ALLOW_UPDATES ! 887: /* ! 888: * If this is a dynamic update request, process it specially; else, ! 889: * execute normal update code. ! 890: */ ! 891: switch(hp->opcode) { ! 892: ! 893: /* For UPDATEM and UPDATEMA, do UPDATED/UPDATEDA followed by UPDATEA */ ! 894: case UPDATEM: ! 895: case UPDATEMA: ! 896: ! 897: /* ! 898: * The named code for UPDATED and UPDATEDA is the same except that for ! 899: * UPDATEDA we we ignore any data that was passed: we just delete all ! 900: * RRs whose name, type, and class matches ! 901: */ ! 902: case UPDATED: ! 903: case UPDATEDA: ! 904: if (type == T_SOA) { /* Not allowed */ ! 905: #ifdef DEBUG ! 906: if (debug) ! 907: fprintf(ddt, "UDPATE: REFUSED - SOA delete\n"); ! 908: #endif ! 909: hp->rcode = REFUSED; ! 910: return(-1); ! 911: } ! 912: /* ! 913: * Don't check message length if doing UPDATEM/UPDATEMA, ! 914: * since the whole message wont have been demarshalled until ! 915: * we reach the code for UPDATEA ! 916: */ ! 917: if ( (hp->opcode == UPDATED) || (hp->opcode == UPDATEDA) ) { ! 918: if (cp != (u_char *)(msg + msglen)) { ! 919: #ifdef DEBUG ! 920: if (debug) ! 921: fprintf(ddt,"FORMERR UPDATE message length off\n"); ! 922: #endif ! 923: hp->rcode = FORMERR; ! 924: return(-1); ! 925: } ! 926: } ! 927: if ((zonenum = findzone(dname, class)) == 0) { ! 928: hp->rcode = NXDOMAIN; ! 929: return(-1); ! 930: } ! 931: if (zones[zonenum].z_state & Z_DYNADDONLY) { ! 932: hp->rcode = NXDOMAIN; ! 933: return(-1); ! 934: } ! 935: if ( (hp->opcode == UPDATED) || (hp->opcode == UPDATEM) ) { ! 936: /* Make a dp for use in db_update, as old dp */ ! 937: dp = savedata(class, type, 0, cp1, n); ! 938: dp->d_zone = zonenum; ! 939: n = db_update(dname, dp, NULL, DB_MEXIST | DB_DELETE, ! 940: hashtab); ! 941: if (n != OK) { ! 942: #ifdef DEBUG ! 943: if (debug) ! 944: fprintf(ddt,"UPDATE: db_update failed\n"); ! 945: #endif DEBUG ! 946: free( (struct databuf *) dp); ! 947: hp->rcode = NOCHANGE; ! 948: return(-1); ! 949: } ! 950: } else { /* UPDATEDA or UPDATEMA */ ! 951: int DeletedOne = 0; ! 952: /* Make a dp for use in db_update, as old dp */ ! 953: dp = savedata(class, type, 0, NULL, 0); ! 954: dp->d_zone = zonenum; ! 955: do { /* Loop and delete all matching RR(s) */ ! 956: n = db_update(dname, dp, NULL, DB_DELETE, ! 957: hashtab); ! 958: if (n != OK) ! 959: break; ! 960: DeletedOne++; ! 961: } while (1); ! 962: free( (struct databuf *) dp); ! 963: /* Ok for UPDATEMA not to have deleted any RRs */ ! 964: if (!DeletedOne && hp->opcode == UPDATEDA) { ! 965: #ifdef DEBUG ! 966: if (debug) ! 967: fprintf(ddt,"UPDATE: db_update failed\n"); ! 968: #endif DEBUG ! 969: hp->rcode = NOCHANGE; ! 970: return(-1); ! 971: } ! 972: } ! 973: if ( (hp->opcode == UPDATED) || (hp->opcode == UPDATEDA) ) ! 974: return (cp - rrp);; ! 975: /* ! 976: * Else unmarshal the RR to be added and continue on to ! 977: * UPDATEA code for UPDATEM/UPDATEMA ! 978: */ ! 979: if ((n = ! 980: dn_expand(msg, msg+msglen, cp, dname, sizeof(dname))) < 0) { ! 981: #ifdef DEBUG ! 982: if (debug) ! 983: fprintf(ddt,"FORMERR UPDATE expand name failed\n"); ! 984: #endif ! 985: hp->rcode = FORMERR; ! 986: return(-1); ! 987: } ! 988: cp += n; ! 989: GETSHORT(type, cp); ! 990: GETSHORT(class, cp); ! 991: GETLONG(ttl, cp); ! 992: GETSHORT(n, cp); ! 993: cp1 = cp; ! 994: /**** XXX - need bounds checking here ****/ ! 995: cp += n; ! 996: ! 997: case UPDATEA: ! 998: if (n > MAXDATA) { ! 999: #ifdef DEBUG ! 1000: if (debug) ! 1001: fprintf(ddt,"UPDATE: too much data\n"); ! 1002: #endif ! 1003: hp->rcode = NOCHANGE; ! 1004: return(-1); ! 1005: } ! 1006: if (cp != (u_char *)(msg + msglen)) { ! 1007: #ifdef DEBUG ! 1008: if (debug) ! 1009: fprintf(ddt,"FORMERR UPDATE message length off\n"); ! 1010: #endif ! 1011: hp->rcode = FORMERR; ! 1012: return(-1); ! 1013: } ! 1014: if ((zonenum = findzone(dname, class)) == 0) { ! 1015: hp->rcode = NXDOMAIN; ! 1016: return(-1); ! 1017: } ! 1018: if (zones[zonenum].z_state & Z_DYNADDONLY) { ! 1019: struct hashbuf *htp = hashtab; ! 1020: char *fname; ! 1021: if (nlookup(dname, &htp, &fname, 0) && ! 1022: !strcmp(dname, fname)) { ! 1023: #ifdef DEBUG ! 1024: if (debug) ! 1025: fprintf(ddt,"refusing add of existing name\n"); ! 1026: #endif ! 1027: hp->rcode = REFUSED; ! 1028: return(-1); ! 1029: } ! 1030: } ! 1031: dp = savedata(class, type, ttl, cp1, n); ! 1032: dp->d_zone = zonenum; ! 1033: if ((n = db_update(dname, NULL, dp, DB_NODATA, ! 1034: hashtab)) != OK) { ! 1035: #ifdef DEBUG ! 1036: if (debug) ! 1037: fprintf(ddt,"UPDATE: db_update failed\n"); ! 1038: #endif ! 1039: hp->rcode = NOCHANGE; ! 1040: return (-1); ! 1041: } ! 1042: else ! 1043: return (cp - rrp); ! 1044: } ! 1045: #endif ALLOW_UPDATES ! 1046: ! 1047: if (zone == 0) ! 1048: ttl += tt.tv_sec; ! 1049: dp = savedata(class, type, ttl, cp1, n); ! 1050: dp->d_zone = zone; ! 1051: if ((n = db_update(dname, dp, dp, flags, hashtab)) < 0) { ! 1052: #ifdef DEBUG ! 1053: if (debug && (n != DATAEXISTS)) ! 1054: fprintf(ddt,"update failed (%d)\n", n); ! 1055: else if (debug >= 3) ! 1056: fprintf(ddt,"update failed (DATAEXISTS)\n"); ! 1057: #endif ! 1058: (void) free((char *)dp); ! 1059: } else if (type == T_NS && savens != NULL) ! 1060: *savens = dp; ! 1061: return (cp - rrp); ! 1062: } ! 1063: ! 1064: send_msg(msg, msglen, qp) ! 1065: char *msg; ! 1066: int msglen; ! 1067: struct qinfo *qp; ! 1068: { ! 1069: extern struct qinfo *qhead; ! 1070: #ifdef DEBUG ! 1071: struct qinfo *tqp; ! 1072: #endif DEBUG ! 1073: ! 1074: if (qp->q_system) ! 1075: return(1); ! 1076: #ifdef DEBUG ! 1077: if (debug) { ! 1078: fprintf(ddt,"send_msg -> %s (%s %d %d) id=%d\n", ! 1079: inet_ntoa(qp->q_from.sin_addr), ! 1080: qp->q_stream == QSTREAM_NULL ? "UDP" : "TCP", ! 1081: qp->q_stream == QSTREAM_NULL ? qp->q_dfd ! 1082: : qp->q_stream->s_rfd, ! 1083: ntohs(qp->q_from.sin_port), ! 1084: ntohs(qp->q_id)); ! 1085: } ! 1086: if (debug>4) ! 1087: for (tqp = qhead; tqp!=QINFO_NULL; tqp = tqp->q_link) { ! 1088: fprintf(ddt, "qp %x q_id: %d q_nsid: %d q_msglen: %d ", ! 1089: tqp, tqp->q_id,tqp->q_nsid,tqp->q_msglen); ! 1090: fprintf(ddt,"q_naddr: %d q_curaddr: %d\n", tqp->q_naddr, ! 1091: tqp->q_curaddr); ! 1092: fprintf(ddt,"q_next: %x q_link: %x\n", qp->q_next, ! 1093: qp->q_link); ! 1094: } ! 1095: if (debug >= 10) ! 1096: fp_query(msg, ddt); ! 1097: #endif DEBUG ! 1098: if (qp->q_stream == QSTREAM_NULL) { ! 1099: if (sendto(qp->q_dfd, msg, msglen, 0, ! 1100: (struct sockaddr *)&qp->q_from, sizeof(qp->q_from)) < 0) { ! 1101: #ifdef DEBUG ! 1102: if (debug) ! 1103: fprintf(ddt, "sendto error errno= %d\n",errno); ! 1104: #endif ! 1105: return(1); ! 1106: } ! 1107: #ifdef STATS ! 1108: stats[S_OUTPKTS].cnt++; ! 1109: #endif ! 1110: } else { ! 1111: (void) writemsg(qp->q_stream->s_rfd, msg, msglen); ! 1112: sq_done(qp->q_stream); ! 1113: } ! 1114: return(0); ! 1115: } ! 1116: ! 1117: prime(class, type, oqp) ! 1118: int class, type; ! 1119: register struct qinfo *oqp; ! 1120: { ! 1121: char dname[BUFSIZ]; ! 1122: ! 1123: if (oqp->q_msg == NULL) ! 1124: return; ! 1125: if (dn_expand(oqp->q_msg, oqp->q_msg + oqp->q_msglen, ! 1126: oqp->q_msg + sizeof(HEADER), dname, sizeof(dname)) < 0) ! 1127: return; ! 1128: #ifdef DEBUG ! 1129: if (debug >= 2) ! 1130: fprintf(ddt,"prime: %s\n", dname); ! 1131: #endif ! 1132: (void) sysquery(dname, class, type); ! 1133: } ! 1134: ! 1135: ! 1136: prime_cache() ! 1137: { ! 1138: register struct qinfo *qp; ! 1139: ! 1140: #ifdef DEBUG ! 1141: if (debug) ! 1142: fprintf(ddt,"prime_cache: priming = %d\n", priming); ! 1143: #endif ! 1144: #ifdef STATS ! 1145: stats[S_PRIMECACHE].cnt++; ! 1146: #endif ! 1147: if (!priming && fcachetab->h_tab[0] != NULL && !forward_only) { ! 1148: priming++; ! 1149: if ((qp = sysquery("", C_IN, T_NS)) == NULL) ! 1150: priming = 0; ! 1151: else ! 1152: qp->q_system = PRIMING_CACHE; ! 1153: } ! 1154: needs_prime_cache = 0; ! 1155: return; ! 1156: } ! 1157: ! 1158: struct qinfo * ! 1159: sysquery(dname, class, type) ! 1160: char *dname; ! 1161: int class, type; ! 1162: { ! 1163: extern struct qinfo *qhead; ! 1164: extern int nsid; ! 1165: register struct qinfo *qp, *oqp; ! 1166: register HEADER *hp; ! 1167: struct namebuf *np; ! 1168: struct databuf *nsp[NSMAX]; ! 1169: struct hashbuf *htp; ! 1170: char *fname; ! 1171: int count; ! 1172: ! 1173: #ifdef DEBUG ! 1174: if (debug > 2) ! 1175: fprintf(ddt,"sysquery(%s, %d, %d)\n", dname, class, type); ! 1176: #endif ! 1177: #ifdef STATS ! 1178: stats[S_SYSQUERIES].cnt++; ! 1179: #endif ! 1180: htp = hashtab; ! 1181: if (priming && dname[0] == '\0') ! 1182: np = NULL; ! 1183: else if ((np = nlookup(dname, &htp, &fname, 1)) == NULL) { ! 1184: #ifdef DEBUG ! 1185: if (debug) ! 1186: fprintf(ddt,"sysquery: nlookup error on %s?\n", dname); ! 1187: #endif ! 1188: return(0); ! 1189: } ! 1190: ! 1191: switch (findns(&np, class, nsp, &count)) { ! 1192: case NXDOMAIN: ! 1193: case SERVFAIL: ! 1194: #ifdef DEBUG ! 1195: if (debug) ! 1196: fprintf(ddt,"sysquery: findns error on %s?\n", dname); ! 1197: #endif ! 1198: return(0); ! 1199: } ! 1200: ! 1201: /* build new qinfo struct */ ! 1202: qp = qnew(); ! 1203: qp->q_cmsg = qp->q_msg = NULL; ! 1204: qp->q_dfd = ds; ! 1205: qp->q_fwd = fwdtab; ! 1206: qp->q_system++; ! 1207: ! 1208: if ((qp->q_msg = malloc(BUFSIZ)) == NULL) { ! 1209: qfree(qp); ! 1210: return(0); ! 1211: } ! 1212: qp->q_msglen = res_mkquery(QUERY, dname, class, ! 1213: type, (char *)NULL, 0, NULL, qp->q_msg, BUFSIZ); ! 1214: hp = (HEADER *) qp->q_msg; ! 1215: hp->id = qp->q_nsid = htons((u_short)++nsid); ! 1216: hp->rd = (qp->q_fwd ? 1 : 0); ! 1217: ! 1218: /* First check for an already pending query for this data */ ! 1219: for (oqp = qhead; oqp!=QINFO_NULL; oqp = oqp->q_link) { ! 1220: if (oqp != qp && oqp->q_msglen == qp->q_msglen && ! 1221: bcmp((char *)oqp->q_msg+2, qp->q_msg+2, qp->q_msglen-2) == 0) { ! 1222: #ifdef DEBUG ! 1223: if (debug >= 3) ! 1224: fprintf(ddt, "sysquery: duplicate\n"); ! 1225: #endif ! 1226: qfree(qp); ! 1227: return(0); ! 1228: } ! 1229: } ! 1230: ! 1231: if (nslookup(nsp, qp) == 0) { ! 1232: #ifdef DEBUG ! 1233: if (debug) ! 1234: fprintf(ddt,"resp: no addrs found for NS's\n"); ! 1235: #endif ! 1236: qfree(qp); ! 1237: return(0); ! 1238: } ! 1239: ! 1240: schedretry(qp, retrytime(qp)); ! 1241: if (qp->q_fwd == 0) ! 1242: qp->q_addr[0].stime = tt; ! 1243: ! 1244: #ifdef DEBUG ! 1245: if (debug) ! 1246: fprintf(ddt,"sysquery: send -> %s %d (%d), nsid=%d id=%d %dms\n", ! 1247: inet_ntoa(Q_NEXTADDR(qp,0)->sin_addr), ! 1248: qp->q_dfd, ntohs(Q_NEXTADDR(qp,0)->sin_port), ! 1249: ntohs(qp->q_nsid), ntohs(qp->q_id), ! 1250: qp->q_addr[0].nsdata->d_nstime); ! 1251: if ( debug >= 10) ! 1252: fp_query(qp->q_msg, ddt); ! 1253: #endif ! 1254: if (sendto(qp->q_dfd, qp->q_msg, qp->q_msglen, 0, ! 1255: (struct sockaddr *)Q_NEXTADDR(qp,0), ! 1256: sizeof(struct sockaddr_in)) < 0){ ! 1257: #ifdef DEBUG ! 1258: if (debug) ! 1259: fprintf(ddt, "sendto error errno= %d\n",errno); ! 1260: #endif ! 1261: } ! 1262: #ifdef STATS ! 1263: stats[S_OUTPKTS].cnt++; ! 1264: #endif ! 1265: return(qp); ! 1266: } ! 1267: ! 1268: /* ! 1269: * Check the list of root servers after receiving a response ! 1270: * to a query for the root servers. ! 1271: */ ! 1272: check_root() ! 1273: { ! 1274: register struct databuf *dp, *pdp; ! 1275: register struct namebuf *np; ! 1276: int count = 0; ! 1277: ! 1278: priming = 0; ! 1279: for (np = hashtab->h_tab[0]; np != NULL; np = np->n_next) ! 1280: if (np->n_dname[0] == '\0') ! 1281: break; ! 1282: if (np == NULL) { ! 1283: syslog(LOG_ERR, "check_root: Can't find root!\n"); ! 1284: return; ! 1285: } ! 1286: for (dp = np->n_data; dp != NULL; dp = dp->d_next) ! 1287: if (dp->d_type == T_NS) ! 1288: count++; ! 1289: #ifdef DEBUG ! 1290: if (debug) ! 1291: fprintf(ddt,"%d root servers\n", count); ! 1292: #endif ! 1293: if (count < MINROOTS) { ! 1294: syslog(LOG_WARNING, ! 1295: "check_root: %d root servers after query to root server < min", ! 1296: count); ! 1297: return; ! 1298: } ! 1299: pdp = NULL; ! 1300: dp = np->n_data; ! 1301: while (dp != NULL) { ! 1302: if (dp->d_type == T_NS && dp->d_zone == 0 && ! 1303: dp->d_ttl < tt.tv_sec) { ! 1304: #ifdef DEBUG ! 1305: if (debug) ! 1306: fprintf(ddt,"deleting old root server '%s'\n", ! 1307: dp->d_data); ! 1308: #endif ! 1309: dp = rm_datum(dp, np, pdp); ! 1310: /* SHOULD DELETE FROM HINTS ALSO */ ! 1311: continue; ! 1312: } ! 1313: pdp = dp; ! 1314: dp = dp->d_next; ! 1315: } ! 1316: check_ns(); ! 1317: } ! 1318: ! 1319: /* ! 1320: * Check the root to make sure that for each NS record we have a A RR ! 1321: */ ! 1322: check_ns() ! 1323: { ! 1324: register struct databuf *dp, *tdp; ! 1325: register struct namebuf *np, *tnp; ! 1326: struct hashbuf *htp; ! 1327: char *dname; ! 1328: int found_arr; ! 1329: char *fname; ! 1330: time_t curtime; ! 1331: ! 1332: #ifdef DEBUG ! 1333: if (debug >= 2) ! 1334: fprintf(ddt,"check_ns()\n"); ! 1335: #endif ! 1336: #ifdef STATS ! 1337: stats[S_CHECKNS].cnt++; ! 1338: #endif ! 1339: ! 1340: curtime = (u_long) tt.tv_sec; ! 1341: for (np = hashtab->h_tab[0]; np != NULL; np = np->n_next) { ! 1342: if (np->n_dname[0] != 0) ! 1343: continue; ! 1344: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 1345: if (dp->d_type != T_NS) ! 1346: continue; ! 1347: ! 1348: /* look for A records */ ! 1349: dname = dp->d_data; ! 1350: htp = hashtab; ! 1351: tnp = nlookup(dname, &htp, &fname, 0); ! 1352: if (tnp == NULL || fname != dname) { ! 1353: #ifdef DEBUG ! 1354: if (debug >= 3) ! 1355: fprintf(ddt,"check_ns: %s: not found %s %x\n", ! 1356: dname, fname, tnp); ! 1357: #endif ! 1358: (void) sysquery(dname, dp->d_class, T_A); ! 1359: continue; ! 1360: } ! 1361: /* look for name server addresses */ ! 1362: found_arr = 0; ! 1363: for (tdp=tnp->n_data; tdp!=NULL; tdp=tdp->d_next) { ! 1364: if (tdp->d_type != T_A || ! 1365: tdp->d_class != dp->d_class) ! 1366: continue; ! 1367: if ((tdp->d_zone == 0) && ! 1368: (tdp->d_ttl < curtime)) { ! 1369: #ifdef DEBUG ! 1370: if (debug >= 3) ! 1371: fprintf(ddt,"check_ns: stale entry '%s'\n", ! 1372: tnp->n_dname); ! 1373: #endif ! 1374: /* Cache invalidate the address RR's */ ! 1375: delete_all(tnp, dp->d_class, T_A); ! 1376: found_arr = 0; ! 1377: break; ! 1378: } ! 1379: found_arr++; ! 1380: } ! 1381: if (!found_arr) ! 1382: (void) sysquery(dname, dp->d_class, T_A); ! 1383: } ! 1384: } ! 1385: } ! 1386: ! 1387: #define MAXCLASS 255 /* belongs elsewhere */ ! 1388: int norootlogged[MAXCLASS]; ! 1389: ! 1390: /* ! 1391: * Find NS's or an SOA for the given dname (np) and fill in the ! 1392: * nsp array. Returns OK on success, and SERVFAIL on error. ! 1393: * We return NXDOMAIN to indicate we are authoritative. ! 1394: */ ! 1395: findns(npp, class, nsp, countp) ! 1396: register struct namebuf **npp; ! 1397: struct databuf **nsp; ! 1398: int *countp; ! 1399: { ! 1400: register struct namebuf *np = *npp; ! 1401: register struct databuf *dp; ! 1402: register struct databuf **nspp; ! 1403: struct hashbuf *htp = hashtab; ! 1404: ! 1405: if (priming && (np == NULL || np->n_dname[0] == '\0')) ! 1406: htp = fcachetab; ! 1407: try_again: ! 1408: if (htp == fcachetab) ! 1409: needs_prime_cache = 1; ! 1410: while (np == NULL && htp != NULL) { ! 1411: #ifdef DEBUG ! 1412: if (debug > 2) ! 1413: fprintf(ddt, "findns: using %s\n", htp == hashtab ? ! 1414: "cache" : "hints"); ! 1415: #endif ! 1416: for (np = htp->h_tab[0]; np != NULL; np = np->n_next) ! 1417: if (np->n_dname[0] == '\0') ! 1418: break; ! 1419: htp = (htp == hashtab ? fcachetab : NULL); /* Fallback */ ! 1420: } ! 1421: while(np != NULL) { ! 1422: #ifdef DEBUG ! 1423: if (debug >= 5) ! 1424: fprintf(ddt, "findns: np 0x%x\n", np); ! 1425: #endif ! 1426: /* Look first for SOA records. */ ! 1427: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 1428: if (dp->d_zone != 0 && match(dp, class, T_SOA)) { ! 1429: #ifdef DEBUG ! 1430: if (debug >= 3) ! 1431: fprintf(ddt,"findns: SOA found\n"); ! 1432: #endif ! 1433: if (zones[dp->d_zone].z_auth) { ! 1434: *npp = np; ! 1435: nsp[0] = dp; ! 1436: return(NXDOMAIN); ! 1437: } else ! 1438: return (SERVFAIL); ! 1439: } ! 1440: } ! 1441: ! 1442: /* If no SOA records, look for NS records. */ ! 1443: nspp = &nsp[0]; ! 1444: *nspp = NULL; ! 1445: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 1446: if (dp->d_type != T_NS || ! 1447: (dp->d_class != class && class != C_ANY)) ! 1448: continue; ! 1449: /* ! 1450: * Don't use records that may become invalid to ! 1451: * reference later when we do the rtt computation. ! 1452: * Never delete our safety-belt information! ! 1453: */ ! 1454: if ((dp->d_zone == 0) && ! 1455: (dp->d_ttl < (tt.tv_sec+900)) && ! 1456: !(dp->d_flags & DB_F_HINT)) { ! 1457: #ifdef DEBUG ! 1458: if (debug) ! 1459: fprintf(ddt,"findns: stale entry '%s'\n", ! 1460: np->n_dname); ! 1461: #endif ! 1462: /* Cache invalidate the NS RR's */ ! 1463: if (dp->d_ttl < tt.tv_sec) ! 1464: delete_all(np, class, T_NS); ! 1465: goto try_parent; ! 1466: } ! 1467: if (nspp < &nsp[NSMAX-1]) ! 1468: *nspp++ = dp; ! 1469: } ! 1470: ! 1471: *countp = nspp - nsp; ! 1472: if (*countp > 0) { ! 1473: #ifdef DEBUG ! 1474: if (debug >= 3) ! 1475: fprintf(ddt,"findns: %d NS's added for '%s'\n", ! 1476: *countp, np->n_dname); ! 1477: #endif ! 1478: *nspp = NULL; ! 1479: *npp = np; ! 1480: return(OK); /* Success, got some NS's */ ! 1481: } ! 1482: try_parent: ! 1483: np = np->n_parent; ! 1484: } ! 1485: if (htp) ! 1486: goto try_again; ! 1487: #ifdef DEBUG ! 1488: if (debug) ! 1489: fprintf(ddt, "findns: No root nameservers for class %d?\n", ! 1490: class); ! 1491: #endif ! 1492: if ((unsigned)class < MAXCLASS && norootlogged[class] == 0) { ! 1493: norootlogged[class] = 1; ! 1494: syslog(LOG_ERR, "No root nameservers for class %d\n", class); ! 1495: } ! 1496: return(SERVFAIL); ! 1497: } ! 1498: ! 1499: /* ! 1500: * Extract RR's from the given node that match class and type. ! 1501: * Return number of bytes added to response. ! 1502: * If no matching data is found, then 0 is returned. ! 1503: */ ! 1504: finddata(np, class, type, hp, dnamep, lenp, countp) ! 1505: struct namebuf *np; ! 1506: int class, type; ! 1507: register HEADER *hp; ! 1508: char **dnamep; ! 1509: int *lenp, *countp; ! 1510: { ! 1511: register struct databuf *dp; ! 1512: register char *cp; ! 1513: int buflen, n, count = 0, foundstale = 0; ! 1514: ! 1515: buflen = *lenp; ! 1516: cp = ((char *)hp) + *countp; ! 1517: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 1518: if (!wanted(dp, class, type)) { ! 1519: if (type == T_CNAME && class == dp->d_class) { ! 1520: /* any data means no CNAME exists */ ! 1521: *countp = 0; ! 1522: return(0); ! 1523: } ! 1524: continue; ! 1525: } ! 1526: if (stale(dp)) { ! 1527: /* ! 1528: * Don't use stale data. ! 1529: * Would like to call delete_all here ! 1530: * and continue, but the data chain would get ! 1531: * munged; can't restart, as make_rr has side ! 1532: * effects (leaving pointers in dnptr). ! 1533: * Just skip this entry for now ! 1534: * and call delete_all at the end. ! 1535: */ ! 1536: #ifdef DEBUG ! 1537: if (debug >=3) ! 1538: fprintf(ddt,"finddata: stale entry '%s'\n",np->n_dname); ! 1539: #endif ! 1540: if (dp->d_zone == 0) ! 1541: foundstale++; ! 1542: continue; ! 1543: } ! 1544: if ((n = make_rr(*dnamep, dp, cp, buflen, 1)) < 0) { ! 1545: hp->tc = 1; ! 1546: *countp = count; ! 1547: return(*lenp - buflen); ! 1548: } ! 1549: ! 1550: cp += n; ! 1551: buflen -= n; ! 1552: count++; ! 1553: #ifdef notdef ! 1554: /* this isn't right for glue records, aa is set in ns_req */ ! 1555: if (dp->d_zone && zones[dp->d_zone].z_auth && class != C_ANY) ! 1556: hp->aa = 1; /* XXX */ ! 1557: #endif ! 1558: if (dp->d_type == T_CNAME) { ! 1559: if (type != T_ANY) { /* or T_NS? */ ! 1560: *dnamep = dp->d_data; ! 1561: if (dp->d_zone && zones[dp->d_zone].z_auth && ! 1562: class != C_ANY) /* XXX */ ! 1563: hp->aa = 1; /* XXX */ ! 1564: } ! 1565: break; ! 1566: } ! 1567: } ! 1568: /* ! 1569: * Cache invalidate the other RR's of same type ! 1570: * if some have timed out ! 1571: */ ! 1572: if (foundstale) ! 1573: delete_all(np, class, type); ! 1574: #ifdef DEBUG ! 1575: if (debug >=3) ! 1576: fprintf(ddt,"finddata: added %d class %d type %d RRs\n", ! 1577: count, class, type); ! 1578: #endif ! 1579: *countp = count; ! 1580: return(*lenp - buflen); ! 1581: } ! 1582: ! 1583: /* ! 1584: * Do we want this data record based on the class and type? ! 1585: */ ! 1586: wanted(dp, class, type) ! 1587: struct databuf *dp; ! 1588: int class, type; ! 1589: { ! 1590: ! 1591: #ifdef DEBUG ! 1592: if (debug > 3) ! 1593: fprintf(ddt,"wanted(%x, %d, %d) %d, %d\n", dp, class, type, ! 1594: dp->d_class, dp->d_type); ! 1595: #endif ! 1596: ! 1597: if (dp->d_class != class && class != C_ANY) ! 1598: return (0); ! 1599: if (type == dp->d_type) ! 1600: return (1); ! 1601: switch (dp->d_type) { ! 1602: case T_ANY: ! 1603: case T_CNAME: ! 1604: return (1); ! 1605: } ! 1606: switch (type) { ! 1607: case T_ANY: ! 1608: return (1); ! 1609: ! 1610: case T_MAILB: ! 1611: switch (dp->d_type) { ! 1612: case T_MR: ! 1613: case T_MB: ! 1614: case T_MG: ! 1615: case T_MINFO: ! 1616: return (1); ! 1617: } ! 1618: break; ! 1619: ! 1620: case T_AXFR: ! 1621: if (dp->d_type == T_SOA) ! 1622: return (1); ! 1623: } ! 1624: return (0); ! 1625: } ! 1626: ! 1627: /* ! 1628: * Add RR entries from dpp array to a query/response. ! 1629: * Return the number of bytes added or negative the amount ! 1630: * added if truncation was required. Typically you are ! 1631: * adding NS records to a response. ! 1632: */ ! 1633: add_data(np, dpp, cp, buflen) ! 1634: struct namebuf *np; ! 1635: struct databuf **dpp; ! 1636: register char *cp; ! 1637: int buflen; ! 1638: { ! 1639: register struct databuf *dp; ! 1640: char dname[MAXDNAME]; ! 1641: register int n, count = 0; ! 1642: ! 1643: getname(np, dname, sizeof(dname)); ! 1644: for(dp = *dpp++; dp != NULL; dp = *dpp++) { ! 1645: if (stale(dp)) ! 1646: continue; /* ignore old cache entry */ ! 1647: if ((n = make_rr(dname, dp, cp, buflen, 1)) < 0) ! 1648: return(-count); /* Truncation */ ! 1649: cp += n; ! 1650: buflen -= n; ! 1651: count += n; ! 1652: } ! 1653: return(count); ! 1654: } ! 1655: ! 1656: /* ! 1657: * This is best thought of as a "cache invalidate" function. ! 1658: * It is called whenever a piece of data is determined to have ! 1659: * timed out. It is better to have no information, than to ! 1660: * have partial information you pass off as complete. ! 1661: */ ! 1662: delete_all(np, class, type) ! 1663: register struct namebuf *np; ! 1664: int class, type; ! 1665: { ! 1666: register struct databuf *dp, *pdp; ! 1667: ! 1668: #ifdef DEBUG ! 1669: if (debug > 2) ! 1670: fprintf(ddt,"delete_all: '%s' 0x%x class %d type %d\n", ! 1671: np->n_dname, np, class, type); ! 1672: #endif ! 1673: pdp = NULL; ! 1674: dp = np->n_data; ! 1675: while (dp != NULL) { ! 1676: if ((dp->d_zone == 0) && !(dp->d_flags & DB_F_HINT) ! 1677: && match(dp, class, type)) { ! 1678: dp = rm_datum(dp, np, pdp); ! 1679: continue; ! 1680: } ! 1681: pdp = dp; ! 1682: dp = dp->d_next; ! 1683: } ! 1684: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.