![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ns_forw.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_forw.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1986 The 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_forw.c 4.30 (Berkeley) 6/27/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #include <sys/param.h> ! 25: #include <sys/time.h> ! 26: #include <sys/socket.h> ! 27: #include <netinet/in.h> ! 28: #include <syslog.h> ! 29: #include <arpa/nameser.h> ! 30: #include <stdio.h> ! 31: #include "ns.h" ! 32: #include "db.h" ! 33: ! 34: struct qinfo *qhead = QINFO_NULL; /* head of allocated queries */ ! 35: struct qinfo *retryqp = QINFO_NULL; /* list of queries to retry */ ! 36: struct fwdinfo *fwdtab; /* list of forwarding hosts */ ! 37: ! 38: int nsid; /* next forwarded query id */ ! 39: extern int forward_only; /* you are only a slave */ ! 40: extern int errno; ! 41: extern u_short ns_port; ! 42: ! 43: time_t retrytime(); ! 44: ! 45: /* ! 46: * Forward the query to get the answer since its not in the database. ! 47: * Returns FW_OK if a request struct is allocated and the query sent. ! 48: * Returns FW_DUP if this is a duplicate of a pending request. ! 49: * Returns FW_NOSERVER if there were no addresses for the nameservers. ! 50: * Returns FW_SERVFAIL on malloc error. ! 51: * (no action is taken on errors and qpp is not filled in.) ! 52: */ ! 53: ns_forw(nsp, msg, msglen, fp, qsp, dfd, qpp) ! 54: struct databuf *nsp[]; ! 55: char *msg; ! 56: int msglen; ! 57: struct sockaddr_in *fp; ! 58: struct qstream *qsp; ! 59: int dfd; ! 60: struct qinfo **qpp; ! 61: { ! 62: register struct qinfo *qp; ! 63: HEADER *hp; ! 64: u_short id; ! 65: extern char *calloc(); ! 66: ! 67: #ifdef DEBUG ! 68: if (debug >= 3) ! 69: fprintf(ddt,"ns_forw()\n"); ! 70: #endif ! 71: ! 72: /* Don't forward if we're already working on it. */ ! 73: hp = (HEADER *) msg; ! 74: id = hp->id; ! 75: /* Look at them all */ ! 76: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) { ! 77: if (qp->q_id == id && ! 78: bcmp((char *)&qp->q_from, fp, sizeof(qp->q_from)) == 0 && ! 79: ((qp->q_cmsglen == 0 && qp->q_msglen == msglen && ! 80: bcmp((char *)qp->q_msg+2, msg+2, msglen-2) == 0) || ! 81: (qp->q_cmsglen == msglen && ! 82: bcmp((char *)qp->q_cmsg+2, msg+2, msglen-2) == 0))) { ! 83: #ifdef DEBUG ! 84: if (debug >= 3) ! 85: fprintf(ddt,"forw: dropped DUP id=%d\n", ntohs(id)); ! 86: #endif ! 87: #ifdef STATS ! 88: stats[S_DUPQUERIES].cnt++; ! 89: #endif ! 90: return (FW_DUP); ! 91: } ! 92: } ! 93: ! 94: qp = qnew(); ! 95: if (nslookup(nsp, qp) == 0) { ! 96: #ifdef DEBUG ! 97: if (debug >= 2) ! 98: fprintf(ddt,"forw: no nameservers found\n"); ! 99: #endif ! 100: qfree(qp); ! 101: return (FW_NOSERVER); ! 102: } ! 103: qp->q_stream = qsp; ! 104: qp->q_curaddr = 0; ! 105: qp->q_fwd = fwdtab; ! 106: qp->q_dfd = dfd; ! 107: qp->q_id = id; ! 108: hp->id = qp->q_nsid = htons((u_short)++nsid); ! 109: hp->ancount = 0; ! 110: hp->nscount = 0; ! 111: hp->arcount = 0; ! 112: qp->q_from = *fp; ! 113: if ((qp->q_msg = malloc((unsigned)msglen)) == NULL) { ! 114: syslog(LOG_ERR, "forw: %m"); ! 115: qfree(qp); ! 116: return (FW_SERVFAIL); ! 117: } ! 118: bcopy(msg, qp->q_msg, qp->q_msglen = msglen); ! 119: if (!qp->q_fwd) { ! 120: hp->rd = 0; ! 121: qp->q_addr[0].stime = tt; ! 122: } ! 123: ! 124: schedretry(qp, retrytime(qp)); ! 125: #ifdef DEBUG ! 126: if (debug) ! 127: fprintf(ddt, ! 128: "forw: forw -> %s %d (%d) nsid=%d id=%d %dms retry %d sec\n", ! 129: inet_ntoa(Q_NEXTADDR(qp,0)->sin_addr), ! 130: ds, ntohs(Q_NEXTADDR(qp,0)->sin_port), ! 131: ntohs(qp->q_nsid), ntohs(qp->q_id), ! 132: qp->q_addr[0].nsdata->d_nstime, ! 133: qp->q_time - tt.tv_sec); ! 134: if ( debug >= 10) ! 135: fp_query(msg, ddt); ! 136: #endif ! 137: if (sendto(ds, msg, msglen, 0, (struct sockaddr *)Q_NEXTADDR(qp,0), ! 138: sizeof(struct sockaddr_in)) < 0){ ! 139: #ifdef DEBUG ! 140: if (debug >= 5) ! 141: fprintf(ddt,"error returning msg errno=%d\n",errno); ! 142: #endif ! 143: } ! 144: #ifdef STATS ! 145: stats[S_OUTPKTS].cnt++; ! 146: #endif ! 147: if (qpp) ! 148: *qpp = qp; ! 149: hp->rd = 1; ! 150: return (0); ! 151: } ! 152: ! 153: /* ! 154: * Lookup the address for each nameserver in `nsp' and add it to ! 155: * the list saved in the qinfo structure. ! 156: */ ! 157: nslookup(nsp, qp) ! 158: struct databuf *nsp[]; ! 159: register struct qinfo *qp; ! 160: { ! 161: register struct namebuf *np; ! 162: register struct databuf *dp, *nsdp; ! 163: register struct qserv *qs; ! 164: register int n, i; ! 165: struct hashbuf *tmphtp; ! 166: char *dname, *fname; ! 167: int oldn, naddr, class, found_arr; ! 168: time_t curtime; ! 169: int qcomp(); ! 170: ! 171: #ifdef DEBUG ! 172: if (debug >= 3) ! 173: fprintf(ddt,"nslookup(nsp=x%x,qp=x%x)\n",nsp,qp); ! 174: #endif ! 175: ! 176: naddr = n = qp->q_naddr; ! 177: curtime = (u_long) tt.tv_sec; ! 178: while ((nsdp = *nsp++) != NULL) { ! 179: class = nsdp->d_class; ! 180: dname = nsdp->d_data; ! 181: #ifdef DEBUG ! 182: if (debug >= 3) ! 183: fprintf(ddt,"nslookup: NS %s c%d t%d (x%x)\n", ! 184: dname, class, nsdp->d_type, nsdp->d_flags); ! 185: #endif ! 186: /* don't put in people we have tried */ ! 187: for (i = 0; i < qp->q_nusedns; i++) ! 188: if (qp->q_usedns[i] == nsdp) { ! 189: #ifdef DEBUG ! 190: if (debug >= 2) ! 191: fprintf(ddt, "skipping used NS w/name %s\n", nsdp->d_data); ! 192: #endif DEBUG ! 193: goto skipserver; ! 194: } ! 195: ! 196: tmphtp = ((nsdp->d_flags & DB_F_HINT) ? fcachetab : hashtab); ! 197: np = nlookup(dname, &tmphtp, &fname, 1); ! 198: if (np == NULL || fname != dname) { ! 199: #ifdef DEBUG ! 200: if (debug >= 3) ! 201: fprintf(ddt,"%s: not found %s %x\n",dname,fname,np); ! 202: #endif ! 203: continue; ! 204: } ! 205: found_arr = 0; ! 206: oldn = n; ! 207: /* look for name server addresses */ ! 208: for (dp = np->n_data; dp != NULL; dp = dp->d_next) { ! 209: if (dp->d_type != T_A || dp->d_class != class) ! 210: continue; ! 211: /* ! 212: * Don't use records that may become invalid to ! 213: * reference later when we do the rtt computation. ! 214: * Never delete our safety-belt information! ! 215: */ ! 216: if ((dp->d_zone == 0) && ! 217: (dp->d_ttl < (curtime+900)) && ! 218: !(dp->d_flags & DB_F_HINT) ) ! 219: { ! 220: #ifdef DEBUG ! 221: if (debug >= 3) ! 222: fprintf(ddt,"nslookup: stale entry '%s'\n", ! 223: np->n_dname); ! 224: #endif ! 225: /* Cache invalidate the NS RR's */ ! 226: if (dp->d_ttl < curtime) ! 227: delete_all(np, class, T_A); ! 228: n = oldn; ! 229: break; ! 230: } ! 231: ! 232: found_arr++; ! 233: /* don't put in duplicates */ ! 234: qs = qp->q_addr; ! 235: for (i = 0; i < n; i++, qs++) ! 236: if (bcmp((char *)&qs->ns_addr.sin_addr, ! 237: dp->d_data, sizeof(struct in_addr)) == 0) ! 238: goto skipaddr; ! 239: qs->ns_addr.sin_family = AF_INET; ! 240: qs->ns_addr.sin_port = ns_port; ! 241: qs->ns_addr.sin_addr = ! 242: *(struct in_addr *)dp->d_data; ! 243: qs->ns = nsdp; ! 244: qs->nsdata = dp; ! 245: qp->q_addr[n].nretry = 0; ! 246: n++; ! 247: if (n >= NSMAX) ! 248: goto out; ! 249: skipaddr: ; ! 250: } ! 251: #ifdef DEBUG ! 252: if (debug >= 3) ! 253: fprintf(ddt,"nslookup: %d ns addrs\n", n); ! 254: #endif ! 255: if (found_arr == 0 && qp->q_system == 0) ! 256: (void) sysquery(dname, class, T_A); ! 257: skipserver: ; ! 258: } ! 259: out: ! 260: #ifdef DEBUG ! 261: if (debug >= 3) ! 262: fprintf(ddt,"nslookup: %d ns addrs total\n", n); ! 263: #endif ! 264: qp->q_naddr = n; ! 265: if (n > 1) ! 266: qsort((char *)qp->q_addr, n, sizeof(struct qserv), qcomp); ! 267: return (n - naddr); ! 268: } ! 269: ! 270: qcomp(qs1, qs2) ! 271: struct qserv *qs1, *qs2; ! 272: { ! 273: ! 274: return (qs1->nsdata->d_nstime - qs2->nsdata->d_nstime); ! 275: } ! 276: ! 277: /* ! 278: * Arrange that forwarded query (qp) is retried after t seconds. ! 279: */ ! 280: schedretry(qp, t) ! 281: struct qinfo *qp; ! 282: time_t t; ! 283: { ! 284: register struct qinfo *qp1, *qp2; ! 285: ! 286: #ifdef DEBUG ! 287: if (debug > 3) { ! 288: fprintf(ddt,"schedretry(%#x, %dsec)\n", qp, t); ! 289: if (qp->q_time) ! 290: fprintf(ddt,"WARNING: schedretry(%x,%d) q_time already %d\n", qp->q_time); ! 291: } ! 292: #endif ! 293: t += (u_long) tt.tv_sec; ! 294: qp->q_time = t; ! 295: ! 296: if ((qp1 = retryqp) == NULL) { ! 297: retryqp = qp; ! 298: qp->q_next = NULL; ! 299: return; ! 300: } ! 301: if (t < qp1->q_time) { ! 302: qp->q_next = qp1; ! 303: retryqp = qp; ! 304: return; ! 305: } ! 306: while ((qp2 = qp1->q_next) != NULL && qp2->q_time < t) ! 307: qp1 = qp2; ! 308: qp1->q_next = qp; ! 309: qp->q_next = qp2; ! 310: } ! 311: ! 312: /* ! 313: * Unsched is called to remove a forwarded query entry. ! 314: */ ! 315: unsched(qp) ! 316: struct qinfo *qp; ! 317: { ! 318: register struct qinfo *np; ! 319: ! 320: #ifdef DEBUG ! 321: if (debug > 3) { ! 322: fprintf(ddt,"unsched(%#x, %d )\n", qp, ntohs(qp->q_id)); ! 323: } ! 324: #endif ! 325: if( retryqp == qp ) { ! 326: retryqp = qp->q_next; ! 327: } else { ! 328: for( np=retryqp; np->q_next != QINFO_NULL; np = np->q_next ) { ! 329: if( np->q_next != qp) ! 330: continue; ! 331: np->q_next = qp->q_next; /* dequeue */ ! 332: break; ! 333: } ! 334: } ! 335: qp->q_next = QINFO_NULL; /* sanity check */ ! 336: qp->q_time = 0; ! 337: } ! 338: ! 339: /* ! 340: * Retry is called to retransmit query 'qp'. ! 341: */ ! 342: retry(qp) ! 343: register struct qinfo *qp; ! 344: { ! 345: register int n; ! 346: register HEADER *hp; ! 347: ! 348: #ifdef DEBUG ! 349: if (debug > 3) ! 350: fprintf(ddt,"retry(x%x) id=%d\n", qp, ntohs(qp->q_id)); ! 351: #endif ! 352: if((HEADER *)qp->q_msg == NULL) { /*** XXX ***/ ! 353: qremove(qp); ! 354: return; ! 355: } /*** XXX ***/ ! 356: ! 357: /* try next address */ ! 358: n = qp->q_curaddr; ! 359: if (qp->q_fwd) { ! 360: qp->q_fwd = qp->q_fwd->next; ! 361: if (qp->q_fwd) ! 362: goto found; ! 363: /* out of forwarders, try direct queries */ ! 364: } else ! 365: ++qp->q_addr[n].nretry; ! 366: if (!forward_only) { ! 367: do { ! 368: if (++n >= qp->q_naddr) ! 369: n = 0; ! 370: if (qp->q_addr[n].nretry < MAXRETRY) ! 371: goto found; ! 372: } while (n != qp->q_curaddr); ! 373: } ! 374: /* ! 375: * Give up. Can't reach destination. ! 376: */ ! 377: hp = (HEADER *)(qp->q_cmsg ? qp->q_cmsg : qp->q_msg); ! 378: if (qp->q_system == PRIMING_CACHE) { ! 379: /* Can't give up priming */ ! 380: unsched(qp); ! 381: schedretry(qp, (time_t)60*60); /* 1 hour */ ! 382: hp->rcode = NOERROR; /* Lets be safe, reset the query */ ! 383: hp->qr = hp->aa = 0; ! 384: qp->q_fwd = fwdtab; ! 385: for (n = 0; n < qp->q_naddr; n++) ! 386: qp->q_addr[n].nretry = 0; ! 387: return; ! 388: } ! 389: #ifdef DEBUG ! 390: if (debug >= 5) ! 391: fprintf(ddt,"give up\n"); ! 392: #endif ! 393: n = ((HEADER *)qp->q_cmsg ? qp->q_cmsglen : qp->q_msglen); ! 394: hp->id = qp->q_id; ! 395: hp->qr = 1; ! 396: hp->ra = 1; ! 397: hp->rd = 1; ! 398: hp->rcode = SERVFAIL; ! 399: #ifdef DEBUG ! 400: if (debug >= 10) ! 401: fp_query(qp->q_msg, ddt); ! 402: #endif ! 403: if (send_msg((char *)hp, n, qp)) { ! 404: #ifdef DEBUG ! 405: if (debug) ! 406: fprintf(ddt,"gave up retry(x%x) nsid=%d id=%d\n", ! 407: qp, ntohs(qp->q_nsid), ntohs(qp->q_id)); ! 408: #endif ! 409: } ! 410: qremove(qp); ! 411: return; ! 412: ! 413: found: ! 414: if (qp->q_fwd == 0 && qp->q_addr[n].nretry == 0) ! 415: qp->q_addr[n].stime = tt; ! 416: qp->q_curaddr = n; ! 417: hp = (HEADER *)qp->q_msg; ! 418: hp->rd = (qp->q_fwd ? 1 : 0); ! 419: #ifdef DEBUG ! 420: if (debug) ! 421: fprintf(ddt,"%s(addr=%d n=%d) -> %s %d (%d) nsid=%d id=%d %dms\n", ! 422: (qp->q_fwd ? "reforw" : "resend"), ! 423: n, qp->q_addr[n].nretry, ! 424: inet_ntoa(Q_NEXTADDR(qp,n)->sin_addr), ! 425: ds, ntohs(Q_NEXTADDR(qp,n)->sin_port), ! 426: ntohs(qp->q_nsid), ntohs(qp->q_id), ! 427: qp->q_addr[n].nsdata->d_nstime); ! 428: if ( debug >= 10) ! 429: fp_query(qp->q_msg, ddt); ! 430: #endif ! 431: /* NOSTRICT */ ! 432: if (sendto(ds, qp->q_msg, qp->q_msglen, 0, ! 433: (struct sockaddr *)Q_NEXTADDR(qp,n), ! 434: sizeof(struct sockaddr_in)) < 0){ ! 435: #ifdef DEBUG ! 436: if (debug > 3) ! 437: fprintf(ddt,"error resending msg errno=%d\n",errno); ! 438: #endif ! 439: } ! 440: hp->rd = 1; /* leave set to 1 for dup detection */ ! 441: #ifdef STATS ! 442: stats[S_OUTPKTS].cnt++; ! 443: #endif ! 444: unsched(qp); ! 445: schedretry(qp, qp->q_fwd ? (2*RETRYBASE) : retrytime(qp)); ! 446: } ! 447: ! 448: /* ! 449: * Compute retry time for the next server for a query. ! 450: * Use a minimum time of RETRYBASE (4 sec.) or twice the estimated ! 451: * service time; * back off exponentially on retries, but place a 45-sec. ! 452: * ceiling on retry times for now. (This is because we don't hold a reference ! 453: * on servers or their addresses, and we have to finish before they time out.) ! 454: */ ! 455: time_t ! 456: retrytime(qp) ! 457: register struct qinfo *qp; ! 458: { ! 459: time_t t; ! 460: struct qserv *ns = &qp->q_addr[qp->q_curaddr]; ! 461: ! 462: #ifdef DEBUG ! 463: if (debug > 3) ! 464: fprintf(ddt,"retrytime: nstime %dms.\n", ! 465: ns->nsdata->d_nstime / 1000); ! 466: #endif ! 467: t = (time_t) MAX(RETRYBASE, 2 * ns->nsdata->d_nstime / 1000); ! 468: t <<= ns->nretry; ! 469: t = MIN(t, 45); /* max. retry timeout for now */ ! 470: #ifdef notdef ! 471: if (qp->q_system) ! 472: return ((2 * t) + 5); /* system queries can wait. */ ! 473: #endif ! 474: return (t); ! 475: } ! 476: ! 477: qflush() ! 478: { ! 479: while (qhead) ! 480: qremove(qhead); ! 481: qhead = QINFO_NULL; ! 482: } ! 483: ! 484: qremove(qp) ! 485: register struct qinfo *qp; ! 486: { ! 487: #ifdef DEBUG ! 488: if(debug > 3) ! 489: fprintf(ddt,"qremove(x%x)\n", qp); ! 490: #endif ! 491: unsched(qp); /* get off queue first */ ! 492: qfree(qp); ! 493: } ! 494: ! 495: struct qinfo * ! 496: qfindid(id) ! 497: register u_short id; ! 498: { ! 499: register struct qinfo *qp; ! 500: ! 501: #ifdef DEBUG ! 502: if(debug > 3) ! 503: fprintf(ddt,"qfindid(%d)\n", ntohs(id)); ! 504: #endif ! 505: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) { ! 506: if (qp->q_nsid == id) ! 507: return(qp); ! 508: } ! 509: #ifdef DEBUG ! 510: if (debug >= 5) ! 511: fprintf(ddt,"qp not found\n"); ! 512: #endif ! 513: return(NULL); ! 514: } ! 515: ! 516: struct qinfo * ! 517: qnew() ! 518: { ! 519: register struct qinfo *qp; ! 520: ! 521: if ((qp = (struct qinfo *)calloc(1, sizeof(struct qinfo))) == NULL) { ! 522: #ifdef DEBUG ! 523: if (debug >= 5) ! 524: fprintf(ddt,"qnew: calloc error\n"); ! 525: #endif ! 526: syslog(LOG_ERR, "forw: %m"); ! 527: exit(12); ! 528: } ! 529: #ifdef DEBUG ! 530: if (debug >= 5) ! 531: fprintf(ddt,"qnew(x%x)\n", qp); ! 532: #endif ! 533: qp->q_link = qhead; ! 534: qhead = qp; ! 535: return( qp ); ! 536: } ! 537: ! 538: qfree(qp) ! 539: struct qinfo *qp; ! 540: { ! 541: register struct qinfo *np; ! 542: ! 543: #ifdef DEBUG ! 544: if(debug > 3) ! 545: fprintf(ddt,"qfree( x%x )\n", qp); ! 546: if(debug && qp->q_next) ! 547: fprintf(ddt,"WARNING: qfree of linked ptr x%x\n", qp); ! 548: #endif ! 549: if (qp->q_msg) ! 550: free(qp->q_msg); ! 551: if (qp->q_cmsg) ! 552: free(qp->q_cmsg); ! 553: if( qhead == qp ) { ! 554: qhead = qp->q_link; ! 555: } else { ! 556: for( np=qhead; np->q_link != QINFO_NULL; np = np->q_link ) { ! 557: if( np->q_link != qp ) continue; ! 558: np->q_link = qp->q_link; /* dequeue */ ! 559: break; ! 560: } ! 561: } ! 562: (void)free((char *)qp); ! 563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.