![[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] / 43BSDTahoe / etc / named|
Return to ns_forw.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / named |
1.1 root 1: /*
2: * Copyright (c) 1986 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 the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: static char sccsid[] = "@(#)ns_forw.c 4.27 (Berkeley) 6/18/88";
20: #endif /* not lint */
21:
22: #include <stdio.h>
23: #include <sys/param.h>
24: #include <sys/time.h>
25: #include <sys/socket.h>
26: #include <netinet/in.h>
27: #include <syslog.h>
28: #include <arpa/nameser.h>
29: #include "ns.h"
30: #include "db.h"
31:
32: struct qinfo *qhead = QINFO_NULL; /* head of allocated queries */
33: struct qinfo *retryqp = QINFO_NULL; /* list of queries to retry */
34: struct fwdinfo *fwdtab; /* list of forwarding hosts */
35:
36: int nsid; /* next forwarded query id */
37: extern int forward_only; /* you are only a slave */
38: extern int errno;
39: extern short ns_port;
40:
41: time_t retrytime();
42:
43: /*
44: * Forward the query to get the answer since its not in the database.
45: * Returns FW_OK if a request struct is allocated and the query sent.
46: * Returns FW_DUP if this is a duplicate of a pending request.
47: * Returns FW_NOSERVER if there were no addresses for the nameservers.
48: * Returns FW_SERVFAIL on malloc error.
49: * (no action is taken on errors and qpp is not filled in.)
50: */
51: ns_forw(nsp, msg, msglen, fp, qsp, dfd, qpp)
52: struct databuf *nsp[];
53: char *msg;
54: int msglen;
55: struct sockaddr_in *fp;
56: struct qstream *qsp;
57: int dfd;
58: struct qinfo **qpp;
59: {
60: register struct qinfo *qp;
61: HEADER *hp;
62: u_short id;
63: extern char *calloc();
64:
65: #ifdef DEBUG
66: if (debug >= 3)
67: fprintf(ddt,"ns_forw()\n");
68: #endif
69:
70: /* Don't forward if we're already working on it. */
71: hp = (HEADER *) msg;
72: id = hp->id;
73: hp->rd = 0;
74: /* Look at them all */
75: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) {
76: if (qp->q_id == id &&
77: bcmp((char *)&qp->q_from, fp, sizeof(qp->q_from)) == 0 &&
78: (qp->q_cmsglen == 0 && qp->q_msglen == msglen &&
79: bcmp((char *)qp->q_msg+2, msg+2, msglen-2) == 0) ||
80: (qp->q_cmsglen == msglen &&
81: bcmp((char *)qp->q_cmsg+2, msg+2, msglen-2) == 0)) {
82: #ifdef DEBUG
83: if (debug >= 3)
84: fprintf(ddt,"forw: dropped DUP id=%d\n", ntohs(id));
85: #endif
86: #ifdef STATS
87: stats[S_DUPQUERIES].cnt++;
88: #endif
89: return (FW_DUP);
90: }
91: }
92:
93: qp = qnew();
94: if (nslookup(nsp, qp) == 0) {
95: #ifdef DEBUG
96: if (debug >= 2)
97: fprintf(ddt,"forw: no nameservers found\n");
98: #endif
99: qfree(qp);
100: hp->rd = 1;
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: if (qp->q_fwd)
113: hp->rd = 1;
114: else
115: qp->q_addr[0].stime = tt;
116: qp->q_from = *fp;
117: if ((qp->q_msg = malloc((unsigned)msglen)) == NULL) {
118: syslog(LOG_ERR, "forw: %m");
119: qfree(qp);
120: return (FW_SERVFAIL);
121: }
122: bcopy(msg, qp->q_msg, qp->q_msglen = msglen);
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 = 0;
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 = (u_short)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: while ((qp2 = qp1->q_next) != NULL && qp2->q_time < t)
302: qp1 = qp2;
303: qp1->q_next = qp;
304: qp->q_next = qp2;
305: }
306:
307: /*
308: * Unsched is called to remove a forwarded query entry.
309: */
310: unsched(qp)
311: struct qinfo *qp;
312: {
313: register struct qinfo *np;
314:
315: #ifdef DEBUG
316: if (debug > 3) {
317: fprintf(ddt,"unsched(%#x, %d )\n", qp, ntohs(qp->q_id));
318: }
319: #endif
320: if( retryqp == qp ) {
321: retryqp = qp->q_next;
322: } else {
323: for( np=retryqp; np->q_next != QINFO_NULL; np = np->q_next ) {
324: if( np->q_next != qp)
325: continue;
326: np->q_next = qp->q_next; /* dequeue */
327: break;
328: }
329: }
330: qp->q_next = QINFO_NULL; /* sanity check */
331: qp->q_time = 0;
332: }
333:
334: /*
335: * Retry is called to retransmit query 'qp'.
336: */
337: retry(qp)
338: register struct qinfo *qp;
339: {
340: register int n;
341: register HEADER *hp;
342:
343: #ifdef DEBUG
344: if (debug > 3)
345: fprintf(ddt,"retry(x%x) id=%d\n", qp, ntohs(qp->q_id));
346: #endif
347: if((HEADER *)qp->q_msg == NULL) { /*** XXX ***/
348: qremove(qp);
349: return;
350: } /*** XXX ***/
351:
352: /* try next address */
353: n = qp->q_curaddr;
354: if (qp->q_fwd) {
355: qp->q_fwd = qp->q_fwd->next;
356: if (qp->q_fwd)
357: goto found;
358: /* out of forwarders, try direct queries */
359: } else
360: ++qp->q_addr[n].nretry;
361: if (!forward_only) {
362: do {
363: if (++n >= qp->q_naddr)
364: n = 0;
365: if (qp->q_addr[n].nretry < MAXRETRY)
366: goto found;
367: } while (n != qp->q_curaddr);
368: }
369: /*
370: * Give up. Can't reach destination.
371: */
372: hp = (HEADER *)(qp->q_cmsg ? qp->q_cmsg : qp->q_msg);
373: if (qp->q_system == PRIMING_CACHE) {
374: /* Can't give up priming */
375: unsched(qp);
376: schedretry(qp, (time_t)60*60); /* 1 hour */
377: hp->rcode = NOERROR; /* Lets be safe, reset the query */
378: hp->qr = hp->aa = 0;
379: qp->q_fwd = fwdtab;
380: for (n = 0; n < qp->q_naddr; n++)
381: qp->q_addr[n].nretry = 0;
382: return;
383: }
384: #ifdef DEBUG
385: if (debug >= 5)
386: fprintf(ddt,"give up\n");
387: #endif
388: n = ((HEADER *)qp->q_cmsg ? qp->q_cmsglen : qp->q_msglen);
389: hp->id = qp->q_id;
390: hp->qr = 1;
391: hp->ra = 1;
392: hp->rd = 1;
393: hp->rcode = SERVFAIL;
394: #ifdef DEBUG
395: if (debug >= 10)
396: fp_query(qp->q_msg, ddt);
397: #endif
398: if (send_msg((char *)hp, n, qp)) {
399: #ifdef DEBUG
400: if (debug)
401: fprintf(ddt,"gave up retry(x%x) nsid=%d id=%d\n",
402: qp, ntohs(qp->q_nsid), ntohs(qp->q_id));
403: #endif
404: }
405: qremove(qp);
406: return;
407:
408: found:
409: if (qp->q_fwd == 0 && qp->q_addr[n].nretry == 0)
410: qp->q_addr[n].stime = tt;
411: qp->q_curaddr = n;
412: hp = (HEADER *)qp->q_msg;
413: hp->rd = (qp->q_fwd ? 1 : 0);
414: #ifdef DEBUG
415: if (debug)
416: fprintf(ddt,"%s(addr=%d n=%d) -> %s %d (%d) nsid=%d id=%d %dms\n",
417: (qp->q_fwd ? "reforw" : "resend"),
418: n, qp->q_addr[n].nretry,
419: inet_ntoa(Q_NEXTADDR(qp,n)->sin_addr),
420: ds, ntohs(Q_NEXTADDR(qp,n)->sin_port),
421: ntohs(qp->q_nsid), ntohs(qp->q_id),
422: qp->q_addr[n].nsdata->d_nstime);
423: if ( debug >= 10)
424: fp_query(qp->q_msg, ddt);
425: #endif
426: /* NOSTRICT */
427: if (sendto(ds, qp->q_msg, qp->q_msglen, 0,
428: (struct sockaddr *)Q_NEXTADDR(qp,n),
429: sizeof(struct sockaddr_in)) < 0){
430: #ifdef DEBUG
431: if (debug > 3)
432: fprintf(ddt,"error resending msg errno=%d\n",errno);
433: #endif
434: }
435: hp->rd = 0; /* leave set to 0 for dup detection */
436: #ifdef STATS
437: stats[S_OUTPKTS].cnt++;
438: #endif
439: unsched(qp);
440: schedretry(qp, qp->q_fwd ? (2*RETRYBASE) : retrytime(qp));
441: }
442:
443: /*
444: * Compute retry time for the next server for a query.
445: * Use a minimum time of RETRYBASE (4 sec.) or twice the estimated
446: * service time; * back off exponentially on retries, but place a 45-sec.
447: * ceiling on retry times for now. (This is because we don't hold a reference
448: * on servers or their addresses, and we have to finish before they time out.)
449: */
450: time_t
451: retrytime(qp)
452: register struct qinfo *qp;
453: {
454: time_t t;
455: struct qserv *ns = &qp->q_addr[qp->q_curaddr];
456:
457: #ifdef DEBUG
458: if (debug > 3)
459: fprintf(ddt,"retrytime: nstime %dms.\n",
460: ns->nsdata->d_nstime / 1000);
461: #endif
462: t = (time_t) MAX(RETRYBASE, 2 * ns->nsdata->d_nstime / 1000);
463: t <<= ns->nretry;
464: t = MIN(t, 45); /* max. retry timeout for now */
465: #ifdef notdef
466: if (qp->q_system)
467: return ((2 * t) + 5); /* system queries can wait. */
468: #endif
469: return (t);
470: }
471:
472: qflush()
473: {
474: while (qhead)
475: qremove(qhead);
476: qhead = QINFO_NULL;
477: }
478:
479: qremove(qp)
480: register struct qinfo *qp;
481: {
482: #ifdef DEBUG
483: if(debug > 3)
484: fprintf(ddt,"qremove(x%x)\n", qp);
485: #endif
486: unsched(qp); /* get off queue first */
487: qfree(qp);
488: }
489:
490: struct qinfo *
491: qfindid(id)
492: register u_short id;
493: {
494: register struct qinfo *qp;
495:
496: #ifdef DEBUG
497: if(debug > 3)
498: fprintf(ddt,"qfindid(%d)\n", ntohs(id));
499: #endif
500: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) {
501: if (qp->q_nsid == id)
502: return(qp);
503: }
504: #ifdef DEBUG
505: if (debug >= 5)
506: fprintf(ddt,"qp not found\n");
507: #endif
508: return(NULL);
509: }
510:
511: struct qinfo *
512: qnew()
513: {
514: register struct qinfo *qp;
515:
516: if ((qp = (struct qinfo *)calloc(1, sizeof(struct qinfo))) == NULL) {
517: #ifdef DEBUG
518: if (debug >= 5)
519: fprintf(ddt,"qnew: calloc error\n");
520: #endif
521: syslog(LOG_ERR, "forw: %m");
522: exit(12);
523: }
524: #ifdef DEBUG
525: if (debug >= 5)
526: fprintf(ddt,"qnew(x%x)\n", qp);
527: #endif
528: qp->q_link = qhead;
529: qhead = qp;
530: return( qp );
531: }
532:
533: qfree(qp)
534: struct qinfo *qp;
535: {
536: register struct qinfo *np;
537:
538: #ifdef DEBUG
539: if(debug > 3)
540: fprintf(ddt,"qfree( x%x )\n", qp);
541: if(debug && qp->q_next)
542: fprintf(ddt,"WARNING: qfree of linked ptr x%x\n", qp);
543: #endif
544: if (qp->q_msg)
545: free(qp->q_msg);
546: if (qp->q_cmsg)
547: free(qp->q_cmsg);
548: if( qhead == qp ) {
549: qhead = qp->q_link;
550: } else {
551: for( np=qhead; np->q_link != QINFO_NULL; np = np->q_link ) {
552: if( np->q_link != qp ) continue;
553: np->q_link = qp->q_link; /* dequeue */
554: break;
555: }
556: }
557: (void)free((char *)qp);
558: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.