![[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] / 43BSD / etc / named|
Return to ns_forw.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / named |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)ns_forw.c 4.3 (Berkeley) 6/4/86";
3: #endif
4:
5: /*
6: * Copyright (c) 1986 Regents of the University of California
7: * All Rights Reserved
8: */
9:
10: #include <stdio.h>
11: #include <sys/types.h>
12: #include <sys/socket.h>
13: #include <sys/time.h>
14: #include <netinet/in.h>
15: #include <syslog.h>
16: #include <arpa/nameser.h>
17: #include "ns.h"
18: #include "db.h"
19:
20: struct qinfo *qhead = QINFO_NULL; /* head of allocated queries */
21: struct qinfo *retryqp = QINFO_NULL; /* list of queries to retry */
22:
23: int nsid; /* next forwarded query id */
24: extern int errno;
25:
26: /*
27: * Forward the query to get the answer since its not in the database.
28: */
29: ns_forw(nsp, msg, msglen, fp, qsp)
30: struct databuf *nsp[];
31: char *msg;
32: int msglen;
33: struct sockaddr_in *fp;
34: struct qstream *qsp;
35: {
36: register struct qinfo *qp;
37: HEADER *hp;
38: u_short id;
39: extern char *calloc();
40: extern char *malloc();
41:
42: #ifdef DEBUG
43: if (debug > 3)
44: fprintf(ddt,"ns_forw()\n");
45: #endif
46:
47: /* Don't forward if we're already working on it. */
48: hp = (HEADER *) msg;
49: id = hp->id;
50: hp->rd = 0;
51: /* Look at them all */
52: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) {
53: if (qp->q_id == id && qp->q_msglen == msglen &&
54: bcmp((char *)qp->q_msg+2, msg+2, msglen-2) == 0)
55: return (0);
56: }
57:
58: qp = qnew();
59: qp->q_naddr = 0;
60: if (nslookup(nsp, qp) == 0) {
61: #ifdef DEBUG
62: if (debug >= 5)
63: fprintf(ddt,"none found in nsp\n");
64: #endif
65: qfree(qp);
66: return (-1);
67: }
68: qp->q_stream = qsp;
69: qp->q_curaddr = 0;
70: qp->q_id = id;
71: hp->id = qp->q_nsid = htons((u_short)++nsid);
72: hp->ancount = 0;
73: hp->nscount = 0;
74: hp->arcount = 0;
75: qp->q_from = *fp;
76: if ((qp->q_msg = malloc((unsigned)msglen)) == NULL) {
77: syslog(LOG_ERR, "forw: %m");
78: exit(1);
79: }
80: bcopy(msg, qp->q_msg, qp->q_msglen = msglen);
81:
82: schedretry(qp, (time_t)RETRYTIME);
83: #ifdef DEBUG
84: if (debug)
85: fprintf(ddt,"forw -> %s (%d)\n",
86: inet_ntoa(qp->q_addr[0].sin_addr),
87: ntohs(qp->q_addr[0].sin_port));
88: if ( debug >= 10)
89: fp_query(msg, ddt);
90: #endif
91: if (sendto(ds, msg, msglen, 0, &qp->q_addr[0],
92: sizeof(qp->q_addr[0])) < 0) {
93: #ifdef DEBUG
94: if (debug >= 5)
95: fprintf(ddt,"error forwarding msg\n");
96: #endif
97: }
98: return (0);
99: }
100:
101: /*
102: * Lookup the address for each nameserver in `nsp' and add it to
103: * the list saved in the qinfo structure.
104: */
105: nslookup(nsp, qp)
106: struct databuf *nsp[];
107: struct qinfo *qp;
108: {
109: register struct namebuf *np;
110: register struct databuf *dp, *pdp;
111: register int n, i;
112: struct databuf *tmp;
113: struct hashbuf *htp;
114: char *dname, *fname;
115: int naddr, class;
116: time_t curtime;
117:
118: extern short ns_port;
119:
120: #ifdef DEBUG
121: if (debug >= 3)
122: fprintf(ddt,"nslookup(nsp=x%x,qp=x%x)\n",nsp,qp);
123: #endif
124:
125: naddr = n = qp->q_naddr;
126: curtime = (u_long) tt.tv_sec;
127: while ((dp = *nsp++) != NULL) {
128: dname = dp->d_data;
129: class = dp->d_class;
130: htp = hashtab; /* lookup relative to root */
131: np = nlookup(dname, &htp, &fname, 0);
132: if (np == NULL || fname != dname) {
133: #ifdef DEBUG
134: if (debug >= 5)
135: fprintf(ddt,"%s: not found\n", dname);
136: #endif
137: continue;
138: }
139: /* look for name server addresses */
140: pdp = NULL;
141: dp = np->n_data;
142: while (dp != NULL) {
143: if (!match(dp, class, T_A))
144: goto skip;
145: if ((dp->d_zone == 0) && (dp->d_ttl < curtime)) {
146: /* delete old cache entry */
147: #ifdef DEBUG
148: if (debug >= 5)
149: fprintf(ddt,"deleting cache entry\n");
150: #endif
151: rminv(dp);
152: tmp = dp->d_next;
153: (void) free((char *)dp);
154: dp = tmp;
155: if (pdp == NULL)
156: np->n_data = dp;
157: else
158: pdp->d_next = dp;
159: continue;
160: }
161: /* don't put in duplicates */
162: for (i = 0; i < n; i++)
163: if (bcmp((char *)&qp->q_addr[i].sin_addr,
164: dp->d_data, sizeof(struct in_addr)) == 0)
165: goto skip;
166: if (n >= MAXNS)
167: break;
168: qp->q_addr[n].sin_family = AF_INET;
169: qp->q_addr[n].sin_addr = *(struct in_addr *)dp->d_data;
170: qp->q_addr[n].sin_port = (u_short)ns_port;
171: qp->q_nretry[n] = 0;
172: n++;
173: skip: pdp = dp;
174: dp = dp->d_next;
175: }
176: if (n >= MAXNS) {
177: #ifdef DEBUG
178: if (debug >= 5)
179: fprintf(ddt,"q_addr table full\n");
180: #endif
181: break;
182: }
183: }
184: qp->q_naddr = n;
185: return (n - naddr);
186: }
187:
188: /*
189: * Arrange that forwarded query (qp) is retried after t seconds.
190: */
191: schedretry(qp, t)
192: struct qinfo *qp;
193: time_t t;
194: {
195: register struct qinfo *qp1, *qp2;
196:
197: #ifdef DEBUG
198: if (debug > 3) {
199: fprintf(ddt,"schedretry(%#x, %d)\n", qp, t);
200: if (qp->q_time)
201: fprintf(ddt,"WARNING: schedretry(%x,%d) q_time already %d\n", qp->q_time);
202: }
203: #endif
204: t += (u_long) tt.tv_sec;
205: qp->q_time = t;
206:
207: if ((qp1 = retryqp) == NULL) {
208: retryqp = qp;
209: qp->q_next = NULL;
210: return;
211: }
212: while ((qp2 = qp1->q_next) != NULL && qp2->q_time < t)
213: qp1 = qp2;
214: qp1->q_next = qp;
215: qp->q_next = qp2;
216: }
217:
218: /*
219: * Unsched is called to remove a forwarded query entry.
220: */
221: unsched(qp)
222: struct qinfo *qp;
223: {
224: register struct qinfo *np;
225:
226: #ifdef DEBUG
227: if (debug > 3) {
228: fprintf(ddt,"unsched(%#x, %d )\n", qp, qp->q_id);
229: }
230: #endif
231: if( retryqp == qp ) {
232: retryqp = qp->q_next;
233: } else {
234: for( np=retryqp; np->q_next != QINFO_NULL; np = np->q_next ) {
235: if( np->q_next != qp)
236: continue;
237: np->q_next = qp->q_next; /* dequeue */
238: break;
239: }
240: }
241: qp->q_next = QINFO_NULL; /* sanity check */
242: qp->q_time = 0;
243: }
244:
245: /*
246: * Retry is called to retransmit query 'qp'.
247: */
248: retry(qp)
249: register struct qinfo *qp;
250: {
251: register int n;
252: register HEADER *hp;
253:
254: #ifdef DEBUG
255: if (debug > 3)
256: fprintf(ddt,"retry(x%x) id=%d\n", qp, ntohs(qp->q_id));
257: #endif
258:
259: /* try next address */
260: n = qp->q_curaddr;
261: ++qp->q_nretry[n];
262: do {
263: if (++n >= qp->q_naddr)
264: n = 0;
265: if (qp->q_nretry[n] < MAXRETRY)
266: goto found;
267: } while (n != qp->q_curaddr);
268: /*
269: * Give up. Can't reach destination.
270: */
271: #ifdef DEBUG
272: if (debug >= 5)
273: fprintf(ddt,"give up\n");
274: #endif
275: hp = (HEADER *)qp->q_msg;
276: hp->qr = 1;
277: hp->rcode = SERVFAIL;
278: hp->ra = 1;
279: #ifdef DEBUG
280: if (debug >= 10)
281: fp_query(qp->q_msg, ddt);
282: #endif
283: if (sendto(ds, qp->q_msg, qp->q_msglen, 0, &qp->q_from,
284: sizeof(qp->q_from))) {
285: #ifdef DEBUG
286: if (debug)
287: fprintf(ddt,"gave up retry(x%x) id=%d\n",
288: qp, ntohs(qp->q_id));
289: #endif
290: }
291: qremove(qp);
292: return;
293: found:
294: qp->q_curaddr = n;
295: #ifdef DEBUG
296: if (debug)
297: fprintf(ddt,"resend(id=%d n=%d) -> %s (%d)\n",ntohs(qp->q_id),
298: n, inet_ntoa(qp->q_addr[n].sin_addr),
299: ntohs(qp->q_addr[n].sin_port));
300: if ( debug >= 10)
301: fp_query(qp->q_msg, ddt);
302: #endif
303: if (sendto(ds, qp->q_msg, qp->q_msglen, 0, &qp->q_addr[n],
304: sizeof(qp->q_addr[0])) < 0) {
305: #ifdef DEBUG
306: if (debug > 3)
307: fprintf(ddt,"error returning msg\n");
308: #endif
309: }
310: unsched(qp);
311: schedretry(qp, (time_t)RETRYTIME);
312: }
313:
314: qremove(qp)
315: register struct qinfo *qp;
316: {
317: #ifdef DEBUG
318: if(debug > 3)
319: fprintf(ddt,"qremove(x%x)\n", qp);
320: #endif
321: unsched(qp); /* get off queue first */
322: free(qp->q_msg);
323: if (qp->q_cmsg);
324: free(qp->q_cmsg);
325: qfree(qp);
326: }
327:
328: struct qinfo *
329: qfindid(id)
330: register u_short id;
331: {
332: register struct qinfo *qp;
333:
334: #ifdef DEBUG
335: if(debug > 3)
336: fprintf(ddt,"qfindid(%d)\n", ntohs(id));
337: #endif
338: for (qp = qhead; qp!=QINFO_NULL; qp = qp->q_link) {
339: if (qp->q_nsid == id)
340: return(qp);
341: }
342: #ifdef DEBUG
343: if (debug >= 5)
344: fprintf(ddt,"qp not found\n");
345: #endif
346: return(NULL);
347: }
348:
349: struct qinfo *
350: qnew()
351: {
352: register struct qinfo *qp;
353:
354: if ((qp = (struct qinfo *)calloc(1, sizeof(struct qinfo))) == NULL) {
355: #ifdef DEBUG
356: if (debug >= 5)
357: fprintf(ddt,"qnew: calloc error\n");
358: #endif
359: syslog(LOG_ERR, "forw: %m");
360: exit(12);
361: }
362: #ifdef DEBUG
363: if (debug >= 5)
364: fprintf(ddt,"qnew(x%x)\n", qp);
365: #endif
366: qp->q_link = qhead;
367: qhead = qp;
368: return( qp );
369: }
370:
371: qfree(qp)
372: struct qinfo *qp;
373: {
374: register struct qinfo *np;
375:
376: #ifdef DEBUG
377: if(debug > 3)
378: fprintf(ddt,"qfree( x%x )\n", qp);
379: if(debug && qp->q_next)
380: fprintf(ddt,"WARNING: qfree of linked ptr x%x\n", qp);
381: #endif
382: if( qhead == qp ) {
383: qhead = qp->q_link;
384: } else {
385: for( np=qhead; np->q_link != QINFO_NULL; np = np->q_link ) {
386: if( np->q_link != qp ) continue;
387: np->q_link = qp->q_link; /* dequeue */
388: break;
389: }
390: }
391: (void)free((char *)qp);
392: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.