]>
Commit | Line | Data |
---|---|---|
495e7591 AM |
1 | Index: squid/src/cf.data.pre |
2 | diff -c squid/src/cf.data.pre:1.245.2.54 squid/src/cf.data.pre:1.245.2.55 | |
3 | *** squid/src/cf.data.pre:1.245.2.54 Sat Nov 29 11:52:58 2003 | |
4 | --- squid/src/cf.data.pre Sat Dec 6 10:19:36 2003 | |
5 | *************** | |
6 | *** 1106,1112 **** | |
7 | ||
8 | NAME: dns_timeout | |
9 | TYPE: time_t | |
10 | ! DEFAULT: 5 minutes | |
11 | LOC: Config.Timeout.idns_query | |
12 | IFDEF: !USE_DNSSERVERS | |
13 | DOC_START | |
14 | --- 1106,1112 ---- | |
15 | ||
16 | NAME: dns_timeout | |
17 | TYPE: time_t | |
18 | ! DEFAULT: 2 minutes | |
19 | LOC: Config.Timeout.idns_query | |
20 | IFDEF: !USE_DNSSERVERS | |
21 | DOC_START | |
22 | *************** | |
23 | *** 1734,1741 **** | |
24 | DEFAULT: 6 hours | |
25 | DOC_START | |
26 | Upper limit on how long Squid will cache positive DNS responses. | |
27 | ! Default is 6 hours (360 minutes). If you want to minimize the | |
28 | ! use of Squid's ipcache, set this to 1, not 0. | |
29 | DOC_END | |
30 | ||
31 | ||
32 | --- 1734,1741 ---- | |
33 | DEFAULT: 6 hours | |
34 | DOC_START | |
35 | Upper limit on how long Squid will cache positive DNS responses. | |
36 | ! Default is 6 hours (360 minutes). This directive must be set | |
37 | ! larger than negative_dns_ttl. | |
38 | DOC_END | |
39 | ||
40 | ||
41 | *************** | |
42 | *** 1743,1751 **** | |
43 | COMMENT: time-units | |
44 | TYPE: time_t | |
45 | LOC: Config.negativeDnsTtl | |
46 | ! DEFAULT: 5 minutes | |
47 | DOC_START | |
48 | Time-to-Live (TTL) for negative caching of failed DNS lookups. | |
49 | DOC_END | |
50 | ||
51 | NAME: range_offset_limit | |
52 | --- 1743,1754 ---- | |
53 | COMMENT: time-units | |
54 | TYPE: time_t | |
55 | LOC: Config.negativeDnsTtl | |
56 | ! DEFAULT: 1 minute | |
57 | DOC_START | |
58 | Time-to-Live (TTL) for negative caching of failed DNS lookups. | |
59 | + This also makes sets the lower cache limit on positive lookups. | |
60 | + Minimum value is 1 second, and it is not recommendable to go | |
61 | + much below 10 seconds. | |
62 | DOC_END | |
63 | ||
64 | NAME: range_offset_limit | |
65 | *************** | |
66 | *** 1776,1792 **** | |
67 | ----------------------------------------------------------------------------- | |
68 | COMMENT_END | |
69 | ||
70 | NAME: connect_timeout | |
71 | COMMENT: time-units | |
72 | TYPE: time_t | |
73 | LOC: Config.Timeout.connect | |
74 | ! DEFAULT: 2 minutes | |
75 | DOC_START | |
76 | ! Some systems (notably Linux) can not be relied upon to properly | |
77 | ! time out connect(2) requests. Therefore the Squid process | |
78 | ! enforces its own timeout on server connections. This parameter | |
79 | ! specifies how long to wait for the connect to complete. The | |
80 | ! default is two minutes (120 seconds). | |
81 | DOC_END | |
82 | ||
83 | NAME: peer_connect_timeout | |
84 | --- 1779,1803 ---- | |
85 | ----------------------------------------------------------------------------- | |
86 | COMMENT_END | |
87 | ||
88 | + NAME: forward_timeout | |
89 | + COMMENT: time-units | |
90 | + TYPE: time_t | |
91 | + LOC: Config.Timeout.forward | |
92 | + DEFAULT: 4 minutes | |
93 | + DOC_START | |
94 | + This parameter specifies how long Squid should at most attempt in | |
95 | + finding a forwarding path for the request before giving up. | |
96 | + DOC_END | |
97 | + | |
98 | NAME: connect_timeout | |
99 | COMMENT: time-units | |
100 | TYPE: time_t | |
101 | LOC: Config.Timeout.connect | |
102 | ! DEFAULT: 1 minute | |
103 | DOC_START | |
104 | ! This parameter specifies how long to wait for the TCP connect to | |
105 | ! the requested server or peer to complete before Squid should | |
106 | ! attempt to find another path where to forward the request. | |
107 | DOC_END | |
108 | ||
109 | NAME: peer_connect_timeout | |
110 | Index: squid/src/cache_cf.c | |
111 | diff -c squid/src/cache_cf.c:1.396.2.15 squid/src/cache_cf.c:1.396.2.16 | |
112 | *** squid/src/cache_cf.c:1.396.2.15 Thu Nov 6 09:50:37 2003 | |
113 | --- squid/src/cache_cf.c Sat Dec 6 10:19:36 2003 | |
114 | *************** | |
115 | *** 431,436 **** | |
116 | --- 431,444 ---- | |
117 | debug(22, 0) ("WARNING: 'maxconn' ACL (%s) won't work with client_db disabled\n", a->name); | |
118 | } | |
119 | } | |
120 | + if (Config.negativeDnsTtl <= 0) { | |
121 | + debug(22, 0) ("WARNING: resetting negative_dns_ttl to 1 second\n"); | |
122 | + Config.negativeDnsTtl = 1; | |
123 | + } | |
124 | + if (Config.positiveDnsTtl < Config.negativeDnsTtl) { | |
125 | + debug(22, 0) ("NOTICE: positive_dns_ttl must be larger than negative_dns_ttl. Resetting negative_dns_ttl to match\n"); | |
126 | + Config.positiveDnsTtl = Config.negativeDnsTtl; | |
127 | + } | |
128 | } | |
129 | ||
130 | /* Parse a time specification from the config file. Store the | |
131 | Index: squid/src/dns.c | |
132 | diff -c squid/src/dns.c:1.86.2.1 squid/src/dns.c:1.86.2.2 | |
133 | *** squid/src/dns.c:1.86.2.1 Tue Nov 12 00:12:22 2002 | |
134 | --- squid/src/dns.c Sat Dec 6 10:19:37 2003 | |
135 | *************** | |
136 | *** 97,103 **** | |
137 | if (squid_curtime - first_warn > 3 * 60) | |
138 | fatal("DNS servers not responding for 3 minutes"); | |
139 | debug(34, 1) ("dnsSubmit: queue overload, rejecting %s\n", lookup); | |
140 | ! callback(data, "$fail Temporary network problem, please retry later"); | |
141 | return; | |
142 | } | |
143 | first_warn = 0; | |
144 | --- 97,103 ---- | |
145 | if (squid_curtime - first_warn > 3 * 60) | |
146 | fatal("DNS servers not responding for 3 minutes"); | |
147 | debug(34, 1) ("dnsSubmit: queue overload, rejecting %s\n", lookup); | |
148 | ! callback(data, (char *) "$fail Temporary network problem, please retry later"); | |
149 | return; | |
150 | } | |
151 | first_warn = 0; | |
152 | *************** | |
153 | *** 112,118 **** | |
154 | snmp_netDnsFn(variable_list * Var, snint * ErrP) | |
155 | { | |
156 | variable_list *Answer = NULL; | |
157 | ! debug(49, 5) ("snmp_netDnsFn: Processing request:\n", Var->name[LEN_SQ_NET + 1]); | |
158 | snmpDebugOid(5, Var->name, Var->name_length); | |
159 | *ErrP = SNMP_ERR_NOERROR; | |
160 | switch (Var->name[LEN_SQ_NET + 1]) { | |
161 | --- 112,118 ---- | |
162 | snmp_netDnsFn(variable_list * Var, snint * ErrP) | |
163 | { | |
164 | variable_list *Answer = NULL; | |
165 | ! debug(49, 5) ("snmp_netDnsFn: Processing request: %d\n", Var->name[LEN_SQ_NET + 1]); | |
166 | snmpDebugOid(5, Var->name, Var->name_length); | |
167 | *ErrP = SNMP_ERR_NOERROR; | |
168 | switch (Var->name[LEN_SQ_NET + 1]) { | |
169 | Index: squid/src/dns_internal.c | |
170 | diff -c squid/src/dns_internal.c:1.45.2.1 squid/src/dns_internal.c:1.45.2.2 | |
171 | *** squid/src/dns_internal.c:1.45.2.1 Tue Jun 25 05:44:35 2002 | |
172 | --- squid/src/dns_internal.c Sat Dec 6 10:19:37 2003 | |
173 | *************** | |
174 | *** 64,69 **** | |
175 | --- 64,71 ---- | |
176 | IDNSCB *callback; | |
177 | void *callback_data; | |
178 | int attempt; | |
179 | + const char *error; | |
180 | + int rcode; | |
181 | }; | |
182 | ||
183 | struct _ns { | |
184 | *************** | |
185 | *** 463,471 **** | |
186 | } | |
187 | dlinkDelete(&q->lru, &lru_list); | |
188 | idnsRcodeCount(n, q->attempt); | |
189 | if (n < 0) { | |
190 | debug(78, 3) ("idnsGrokReply: error %d\n", rfc1035_errno); | |
191 | ! if (-2 == n && ++q->attempt < MAX_ATTEMPT) { | |
192 | /* | |
193 | * RCODE 2 is "Server failure - The name server was | |
194 | * unable to process this query due to a problem with | |
195 | --- 465,476 ---- | |
196 | } | |
197 | dlinkDelete(&q->lru, &lru_list); | |
198 | idnsRcodeCount(n, q->attempt); | |
199 | + q->error = NULL; | |
200 | if (n < 0) { | |
201 | debug(78, 3) ("idnsGrokReply: error %d\n", rfc1035_errno); | |
202 | ! q->error = rfc1035_error_message; | |
203 | ! q->rcode = -n; | |
204 | ! if (q->rcode == 2 && ++q->attempt < MAX_ATTEMPT) { | |
205 | /* | |
206 | * RCODE 2 is "Server failure - The name server was | |
207 | * unable to process this query due to a problem with | |
208 | *************** | |
209 | *** 481,487 **** | |
210 | valid = cbdataValid(q->callback_data); | |
211 | cbdataUnlock(q->callback_data); | |
212 | if (valid) | |
213 | ! q->callback(q->callback_data, answers, n); | |
214 | rfc1035RRDestroy(answers, n); | |
215 | memFree(q, MEM_IDNS_QUERY); | |
216 | } | |
217 | --- 486,492 ---- | |
218 | valid = cbdataValid(q->callback_data); | |
219 | cbdataUnlock(q->callback_data); | |
220 | if (valid) | |
221 | ! q->callback(q->callback_data, answers, n, q->error); | |
222 | rfc1035RRDestroy(answers, n); | |
223 | memFree(q, MEM_IDNS_QUERY); | |
224 | } | |
225 | *************** | |
226 | *** 571,577 **** | |
227 | /* name servers went away; reconfiguring or shutting down */ | |
228 | break; | |
229 | q = n->data; | |
230 | ! if (tvSubDsec(q->sent_t, current_time) < Config.Timeout.idns_retransmit * (1 << q->nsends % nns)) | |
231 | break; | |
232 | debug(78, 3) ("idnsCheckQueue: ID %#04x timeout\n", | |
233 | q->id); | |
234 | --- 576,582 ---- | |
235 | /* name servers went away; reconfiguring or shutting down */ | |
236 | break; | |
237 | q = n->data; | |
238 | ! if (tvSubDsec(q->sent_t, current_time) < Config.Timeout.idns_retransmit * 1 << ((q->nsends - 1) / nns)) | |
239 | break; | |
240 | debug(78, 3) ("idnsCheckQueue: ID %#04x timeout\n", | |
241 | q->id); | |
242 | *************** | |
243 | *** 585,592 **** | |
244 | (int) q->id, q->nsends, | |
245 | tvSubDsec(q->start_t, current_time)); | |
246 | cbdataUnlock(q->callback_data); | |
247 | ! if (v) | |
248 | ! q->callback(q->callback_data, NULL, 0); | |
249 | memFree(q, MEM_IDNS_QUERY); | |
250 | } | |
251 | } | |
252 | --- 590,601 ---- | |
253 | (int) q->id, q->nsends, | |
254 | tvSubDsec(q->start_t, current_time)); | |
255 | cbdataUnlock(q->callback_data); | |
256 | ! if (v) { | |
257 | ! if (q->rcode != 0) | |
258 | ! q->callback(q->callback_data, NULL, -q->rcode, q->error); | |
259 | ! else | |
260 | ! q->callback(q->callback_data, NULL, -16, "Timeout"); | |
261 | ! } | |
262 | memFree(q, MEM_IDNS_QUERY); | |
263 | } | |
264 | } | |
265 | *************** | |
266 | *** 683,689 **** | |
267 | q->id = rfc1035BuildAQuery(name, q->buf, &q->sz); | |
268 | if (0 == q->id) { | |
269 | /* problem with query data -- query not sent */ | |
270 | ! callback(data, NULL, 0); | |
271 | memFree(q, MEM_IDNS_QUERY); | |
272 | return; | |
273 | } | |
274 | --- 692,698 ---- | |
275 | q->id = rfc1035BuildAQuery(name, q->buf, &q->sz); | |
276 | if (0 == q->id) { | |
277 | /* problem with query data -- query not sent */ | |
278 | ! callback(data, NULL, 0, "Internal error"); | |
279 | memFree(q, MEM_IDNS_QUERY); | |
280 | return; | |
281 | } | |
282 | Index: squid/src/forward.c | |
283 | diff -c squid/src/forward.c:1.82.2.5 squid/src/forward.c:1.82.2.6 | |
284 | *** squid/src/forward.c:1.82.2.5 Sat Nov 29 11:53:00 2003 | |
285 | --- squid/src/forward.c Sat Dec 6 10:19:37 2003 | |
286 | *************** | |
287 | *** 138,144 **** | |
288 | return 0; | |
289 | if (fwdState->origin_tries > 2) | |
290 | return 0; | |
291 | ! if (squid_curtime - fwdState->start > Config.Timeout.connect) | |
292 | return 0; | |
293 | if (fwdState->flags.dont_retry) | |
294 | return 0; | |
295 | --- 138,144 ---- | |
296 | return 0; | |
297 | if (fwdState->origin_tries > 2) | |
298 | return 0; | |
299 | ! if (squid_curtime - fwdState->start > Config.Timeout.forward) | |
300 | return 0; | |
301 | if (fwdState->flags.dont_retry) | |
302 | return 0; | |
303 | *************** | |
304 | *** 365,371 **** | |
305 | FwdServer *fs = fwdState->servers; | |
306 | const char *host; | |
307 | unsigned short port; | |
308 | ! time_t ctimeout; | |
309 | struct in_addr outgoing; | |
310 | unsigned short tos; | |
311 | assert(fs); | |
312 | --- 365,372 ---- | |
313 | FwdServer *fs = fwdState->servers; | |
314 | const char *host; | |
315 | unsigned short port; | |
316 | ! int ctimeout; | |
317 | ! int ftimeout = Config.Timeout.forward - (squid_curtime - fwdState->start); | |
318 | struct in_addr outgoing; | |
319 | unsigned short tos; | |
320 | assert(fs); | |
321 | *************** | |
322 | *** 386,391 **** | |
323 | --- 387,396 ---- | |
324 | port = fwdState->request->port; | |
325 | ctimeout = Config.Timeout.connect; | |
326 | } | |
327 | + if (ftimeout < 0) | |
328 | + ftimeout = 5; | |
329 | + if (ftimeout < ctimeout) | |
330 | + ctimeout = ftimeout; | |
331 | if (fwdCheckRetriable(fwdState)) { | |
332 | if ((fd = pconnPop(host, port)) >= 0) { | |
333 | debug(17, 3) ("fwdConnectStart: reusing pconn FD %d\n", fd); | |
334 | Index: squid/src/fqdncache.c | |
335 | diff -c squid/src/fqdncache.c:1.149.2.3 squid/src/fqdncache.c:1.149.2.4 | |
336 | *** squid/src/fqdncache.c:1.149.2.3 Thu Dec 4 03:10:12 2003 | |
337 | --- squid/src/fqdncache.c Sat Dec 6 10:19:37 2003 | |
338 | *************** | |
339 | *** 72,81 **** | |
340 | ||
341 | #if USE_DNSSERVERS | |
342 | static HLPCB fqdncacheHandleReply; | |
343 | ! static fqdncache_entry *fqdncacheParse(const char *buf); | |
344 | #else | |
345 | static IDNSCB fqdncacheHandleReply; | |
346 | ! static fqdncache_entry *fqdncacheParse(rfc1035_rr *, int); | |
347 | #endif | |
348 | static void fqdncacheRelease(fqdncache_entry *); | |
349 | static fqdncache_entry *fqdncacheCreateEntry(const char *name); | |
350 | --- 72,81 ---- | |
351 | ||
352 | #if USE_DNSSERVERS | |
353 | static HLPCB fqdncacheHandleReply; | |
354 | ! static fqdncache_entry *fqdncacheParse(fqdncache_entry *, const char *buf); | |
355 | #else | |
356 | static IDNSCB fqdncacheHandleReply; | |
357 | ! static fqdncache_entry *fqdncacheParse(fqdncache_entry *, rfc1035_rr *, int, const char *error_message); | |
358 | #endif | |
359 | static void fqdncacheRelease(fqdncache_entry *); | |
360 | static fqdncache_entry *fqdncacheCreateEntry(const char *name); | |
361 | *************** | |
362 | *** 189,199 **** | |
363 | static void | |
364 | fqdncacheAddEntry(fqdncache_entry * f) | |
365 | { | |
366 | ! hash_link *e = hash_lookup(fqdn_table, f->hash.key); | |
367 | if (NULL != e) { | |
368 | ! /* avoid colission */ | |
369 | ! fqdncache_entry *q = (fqdncache_entry *) e; | |
370 | ! fqdncacheRelease(q); | |
371 | } | |
372 | hash_join(fqdn_table, &f->hash); | |
373 | dlinkAdd(f, &f->lru, &lru_list); | |
374 | --- 189,203 ---- | |
375 | static void | |
376 | fqdncacheAddEntry(fqdncache_entry * f) | |
377 | { | |
378 | ! fqdncache_entry *e = (fqdncache_entry *) hash_lookup(fqdn_table, f->hash.key); | |
379 | if (NULL != e) { | |
380 | ! /* avoid collision */ | |
381 | ! if (f->flags.negcached && !e->flags.negcached && e->expires > squid_curtime) { | |
382 | ! /* Don't waste good information */ | |
383 | ! fqdncacheFreeEntry(f); | |
384 | ! return; | |
385 | ! } | |
386 | ! fqdncacheRelease(e); | |
387 | } | |
388 | hash_join(fqdn_table, &f->hash); | |
389 | dlinkAdd(f, &f->lru, &lru_list); | |
390 | *************** | |
391 | *** 222,317 **** | |
392 | ||
393 | static fqdncache_entry * | |
394 | #if USE_DNSSERVERS | |
395 | ! fqdncacheParse(const char *inbuf) | |
396 | { | |
397 | LOCAL_ARRAY(char, buf, DNS_INBUF_SZ); | |
398 | char *token; | |
399 | - static fqdncache_entry f; | |
400 | int ttl; | |
401 | ! memset(&f, '\0', sizeof(f)); | |
402 | ! f.expires = squid_curtime; | |
403 | ! f.flags.negcached = 1; | |
404 | if (inbuf == NULL) { | |
405 | ! debug(35, 1) ("fqdncacheParse: Got <NULL> reply\n"); | |
406 | ! return &f; | |
407 | } | |
408 | xstrncpy(buf, inbuf, DNS_INBUF_SZ); | |
409 | debug(35, 5) ("fqdncacheParse: parsing: {%s}\n", buf); | |
410 | token = strtok(buf, w_space); | |
411 | if (NULL == token) { | |
412 | ! debug(35, 1) ("fqdncacheParse: Got <NULL>, expecting '$name'\n"); | |
413 | ! return &f; | |
414 | } | |
415 | if (0 == strcmp(token, "$fail")) { | |
416 | - f.expires = squid_curtime + Config.negativeDnsTtl; | |
417 | token = strtok(NULL, "\n"); | |
418 | assert(NULL != token); | |
419 | ! f.error_message = xstrdup(token); | |
420 | ! return &f; | |
421 | } | |
422 | if (0 != strcmp(token, "$name")) { | |
423 | ! debug(35, 1) ("fqdncacheParse: Got '%s', expecting '$name'\n", token); | |
424 | ! return &f; | |
425 | } | |
426 | token = strtok(NULL, w_space); | |
427 | if (NULL == token) { | |
428 | ! debug(35, 1) ("fqdncacheParse: Got <NULL>, expecting TTL\n"); | |
429 | ! return &f; | |
430 | } | |
431 | ! f.flags.negcached = 0; | |
432 | ttl = atoi(token); | |
433 | ! if (ttl > 0 && ttl < Config.positiveDnsTtl) | |
434 | ! f.expires = squid_curtime + ttl; | |
435 | ! else | |
436 | ! f.expires = squid_curtime + Config.positiveDnsTtl; | |
437 | token = strtok(NULL, w_space); | |
438 | if (NULL != token) { | |
439 | ! f.names[0] = xstrdup(token); | |
440 | ! f.name_count = 1; | |
441 | } | |
442 | ! return &f; | |
443 | } | |
444 | #else | |
445 | ! fqdncacheParse(rfc1035_rr * answers, int nr) | |
446 | { | |
447 | - static fqdncache_entry f; | |
448 | int k; | |
449 | ! int na = 0; | |
450 | ! memset(&f, '\0', sizeof(f)); | |
451 | ! f.expires = squid_curtime + Config.negativeDnsTtl; | |
452 | ! f.flags.negcached = 1; | |
453 | if (nr < 0) { | |
454 | ! debug(35, 3) ("fqdncacheParse: Lookup failed (error %d)\n", | |
455 | ! rfc1035_errno); | |
456 | ! assert(rfc1035_error_message); | |
457 | ! f.error_message = xstrdup(rfc1035_error_message); | |
458 | ! return &f; | |
459 | } | |
460 | if (nr == 0) { | |
461 | ! debug(35, 3) ("fqdncacheParse: No DNS records\n"); | |
462 | ! f.error_message = xstrdup("No DNS records"); | |
463 | ! return &f; | |
464 | } | |
465 | ! debug(35, 3) ("fqdncacheParse: %d answers\n", nr); | |
466 | assert(answers); | |
467 | for (k = 0; k < nr; k++) { | |
468 | if (answers[k].type != RFC1035_TYPE_PTR) | |
469 | continue; | |
470 | if (answers[k].class != RFC1035_CLASS_IN) | |
471 | continue; | |
472 | ! na++; | |
473 | ! f.flags.negcached = 0; | |
474 | ! f.names[0] = xstrndup(answers[k].rdata, answers[k].rdlength); | |
475 | ! f.name_count = 1; | |
476 | ! if (answers[k].ttl < Config.positiveDnsTtl) | |
477 | ! f.expires = squid_curtime + answers[k].ttl; | |
478 | ! else | |
479 | ! f.expires = squid_curtime + Config.positiveDnsTtl; | |
480 | ! return &f; | |
481 | ! } | |
482 | ! debug(35, 1) ("fqdncacheParse: No PTR record\n"); | |
483 | ! f.error_message = xstrdup("No PTR record"); | |
484 | ! return &f; | |
485 | } | |
486 | #endif | |
487 | ||
488 | --- 226,326 ---- | |
489 | ||
490 | static fqdncache_entry * | |
491 | #if USE_DNSSERVERS | |
492 | ! fqdncacheParse(fqdncache_entry * f, const char *inbuf) | |
493 | { | |
494 | LOCAL_ARRAY(char, buf, DNS_INBUF_SZ); | |
495 | char *token; | |
496 | int ttl; | |
497 | ! const char *name = (const char *) f->hash.key; | |
498 | ! f->expires = squid_curtime + Config.negativeDnsTtl; | |
499 | ! f->flags.negcached = 1; | |
500 | if (inbuf == NULL) { | |
501 | ! debug(35, 1) ("fqdncacheParse: Got <NULL> reply in response to '%s'\n", name); | |
502 | ! f->error_message = xstrdup("Internal Error"); | |
503 | ! return f; | |
504 | } | |
505 | xstrncpy(buf, inbuf, DNS_INBUF_SZ); | |
506 | debug(35, 5) ("fqdncacheParse: parsing: {%s}\n", buf); | |
507 | token = strtok(buf, w_space); | |
508 | if (NULL == token) { | |
509 | ! debug(35, 1) ("fqdncacheParse: Got <NULL>, expecting '$name' in response to '%s'\n", name); | |
510 | ! f->error_message = xstrdup("Internal Error"); | |
511 | ! return f; | |
512 | } | |
513 | if (0 == strcmp(token, "$fail")) { | |
514 | token = strtok(NULL, "\n"); | |
515 | assert(NULL != token); | |
516 | ! f->error_message = xstrdup(token); | |
517 | ! return f; | |
518 | } | |
519 | if (0 != strcmp(token, "$name")) { | |
520 | ! debug(35, 1) ("fqdncacheParse: Got '%s', expecting '$name' in response to '%s'\n", inbuf, name); | |
521 | ! f->error_message = xstrdup("Internal Error"); | |
522 | ! return f; | |
523 | } | |
524 | token = strtok(NULL, w_space); | |
525 | if (NULL == token) { | |
526 | ! debug(35, 1) ("fqdncacheParse: Got '%s', expecting TTL in response to '%s'\n", inbuf, name); | |
527 | ! f->error_message = xstrdup("Internal Error"); | |
528 | ! return f; | |
529 | } | |
530 | ! f->flags.negcached = 0; | |
531 | ttl = atoi(token); | |
532 | ! if (ttl == 0 || ttl > Config.positiveDnsTtl) | |
533 | ! ttl = Config.positiveDnsTtl; | |
534 | ! if (ttl < Config.negativeDnsTtl) | |
535 | ! ttl = Config.negativeDnsTtl; | |
536 | ! f->expires = squid_curtime + ttl; | |
537 | token = strtok(NULL, w_space); | |
538 | if (NULL != token) { | |
539 | ! f->names[0] = xstrdup(token); | |
540 | ! f->name_count = 1; | |
541 | } | |
542 | ! return f; | |
543 | } | |
544 | #else | |
545 | ! fqdncacheParse(fqdncache_entry * f, rfc1035_rr * answers, int nr, const char *error_message) | |
546 | { | |
547 | int k; | |
548 | ! int ttl = 0; | |
549 | ! const char *name = (const char *) f->hash.key; | |
550 | ! f->expires = squid_curtime + Config.negativeDnsTtl; | |
551 | ! f->flags.negcached = 1; | |
552 | if (nr < 0) { | |
553 | ! debug(35, 3) ("fqdncacheParse: Lookup of '%s' failed (%s)\n", name, error_message); | |
554 | ! f->error_message = xstrdup(error_message); | |
555 | ! return f; | |
556 | } | |
557 | if (nr == 0) { | |
558 | ! debug(35, 3) ("fqdncacheParse: No DNS records for '%s'\n", name); | |
559 | ! f->error_message = xstrdup("No DNS records"); | |
560 | ! return f; | |
561 | } | |
562 | ! debug(35, 3) ("fqdncacheParse: %d answers for '%s'\n", nr, name); | |
563 | assert(answers); | |
564 | for (k = 0; k < nr; k++) { | |
565 | if (answers[k].type != RFC1035_TYPE_PTR) | |
566 | continue; | |
567 | if (answers[k].class != RFC1035_CLASS_IN) | |
568 | continue; | |
569 | ! f->names[f->name_count++] = xstrndup(answers[k].rdata, answers[k].rdlength); | |
570 | ! if (ttl == 0 || answers[k].ttl < ttl) | |
571 | ! ttl = answers[k].ttl; | |
572 | ! if (f->name_count >= FQDN_MAX_NAMES) | |
573 | ! break; | |
574 | ! } | |
575 | ! if (f->name_count == 0) { | |
576 | ! debug(35, 1) ("fqdncacheParse: No PTR record\n"); | |
577 | ! f->error_message = xstrdup("No PTR record"); | |
578 | ! return f; | |
579 | ! } | |
580 | ! if (ttl == 0 || ttl > Config.positiveDnsTtl) | |
581 | ! ttl = Config.positiveDnsTtl; | |
582 | ! if (ttl < Config.negativeDnsTtl) | |
583 | ! ttl = Config.negativeDnsTtl; | |
584 | ! f->expires = squid_curtime + ttl; | |
585 | ! f->flags.negcached = 0; | |
586 | ! return f; | |
587 | } | |
588 | #endif | |
589 | ||
590 | *************** | |
591 | *** 319,348 **** | |
592 | #if USE_DNSSERVERS | |
593 | fqdncacheHandleReply(void *data, char *reply) | |
594 | #else | |
595 | ! fqdncacheHandleReply(void *data, rfc1035_rr * answers, int na) | |
596 | #endif | |
597 | { | |
598 | int n; | |
599 | generic_cbdata *c = data; | |
600 | fqdncache_entry *f = c->data; | |
601 | - fqdncache_entry *x = NULL; | |
602 | cbdataFree(c); | |
603 | c = NULL; | |
604 | n = ++FqdncacheStats.replies; | |
605 | statHistCount(&statCounter.dns.svc_time, | |
606 | tvSubMsec(f->request_time, current_time)); | |
607 | #if USE_DNSSERVERS | |
608 | ! x = fqdncacheParse(reply); | |
609 | #else | |
610 | ! x = fqdncacheParse(answers, na); | |
611 | #endif | |
612 | - assert(x); | |
613 | - f->name_count = x->name_count; | |
614 | - for (n = 0; n < (int) f->name_count; n++) | |
615 | - f->names[n] = x->names[n]; | |
616 | - f->error_message = x->error_message; | |
617 | - f->expires = x->expires; | |
618 | - f->flags = x->flags; | |
619 | fqdncacheAddEntry(f); | |
620 | fqdncacheCallback(f); | |
621 | } | |
622 | --- 328,349 ---- | |
623 | #if USE_DNSSERVERS | |
624 | fqdncacheHandleReply(void *data, char *reply) | |
625 | #else | |
626 | ! fqdncacheHandleReply(void *data, rfc1035_rr * answers, int na, const char *error_message) | |
627 | #endif | |
628 | { | |
629 | int n; | |
630 | generic_cbdata *c = data; | |
631 | fqdncache_entry *f = c->data; | |
632 | cbdataFree(c); | |
633 | c = NULL; | |
634 | n = ++FqdncacheStats.replies; | |
635 | statHistCount(&statCounter.dns.svc_time, | |
636 | tvSubMsec(f->request_time, current_time)); | |
637 | #if USE_DNSSERVERS | |
638 | ! fqdncacheParse(f, reply); | |
639 | #else | |
640 | ! fqdncacheParse(f, answers, na, error_message); | |
641 | #endif | |
642 | fqdncacheAddEntry(f); | |
643 | fqdncacheCallback(f); | |
644 | } | |
645 | Index: squid/src/ipcache.c | |
646 | diff -c squid/src/ipcache.c:1.236.2.1 squid/src/ipcache.c:1.236.2.2 | |
647 | *** squid/src/ipcache.c:1.236.2.1 Fri Nov 28 12:14:32 2003 | |
648 | --- squid/src/ipcache.c Sat Dec 6 10:19:37 2003 | |
649 | *************** | |
650 | *** 77,85 **** | |
651 | static int ipcacheExpiredEntry(ipcache_entry *); | |
652 | static int ipcache_testname(void); | |
653 | #if USE_DNSSERVERS | |
654 | ! static ipcache_entry *ipcacheParse(const char *buf); | |
655 | #else | |
656 | ! static ipcache_entry *ipcacheParse(rfc1035_rr *, int); | |
657 | #endif | |
658 | static ipcache_entry *ipcache_get(const char *); | |
659 | static void ipcacheLockEntry(ipcache_entry *); | |
660 | --- 77,85 ---- | |
661 | static int ipcacheExpiredEntry(ipcache_entry *); | |
662 | static int ipcache_testname(void); | |
663 | #if USE_DNSSERVERS | |
664 | ! static ipcache_entry *ipcacheParse(ipcache_entry *, const char *buf); | |
665 | #else | |
666 | ! static ipcache_entry *ipcacheParse(ipcache_entry *, rfc1035_rr *, int, const char *error); | |
667 | #endif | |
668 | static ipcache_entry *ipcache_get(const char *); | |
669 | static void ipcacheLockEntry(ipcache_entry *); | |
670 | *************** | |
671 | *** 199,209 **** | |
672 | static void | |
673 | ipcacheAddEntry(ipcache_entry * i) | |
674 | { | |
675 | ! hash_link *e = hash_lookup(ip_table, i->hash.key); | |
676 | if (NULL != e) { | |
677 | ! /* avoid colission */ | |
678 | ! ipcache_entry *q = (ipcache_entry *) e; | |
679 | ! ipcacheRelease(q); | |
680 | } | |
681 | hash_join(ip_table, &i->hash); | |
682 | dlinkAdd(i, &i->lru, &lru_list); | |
683 | --- 199,213 ---- | |
684 | static void | |
685 | ipcacheAddEntry(ipcache_entry * i) | |
686 | { | |
687 | ! ipcache_entry *e = (ipcache_entry *) hash_lookup(ip_table, i->hash.key); | |
688 | if (NULL != e) { | |
689 | ! /* avoid collision */ | |
690 | ! if (i->flags.negcached && !e->flags.negcached && e->expires > squid_curtime) { | |
691 | ! /* Don't waste good information */ | |
692 | ! ipcacheFreeEntry(i); | |
693 | ! return; | |
694 | ! } | |
695 | ! ipcacheRelease(e); | |
696 | } | |
697 | hash_join(ip_table, &i->hash); | |
698 | dlinkAdd(i, &i->lru, &lru_list); | |
699 | *************** | |
700 | *** 230,326 **** | |
701 | ipcacheUnlockEntry(i); | |
702 | } | |
703 | ||
704 | - static ipcache_entry * | |
705 | #if USE_DNSSERVERS | |
706 | ! ipcacheParse(const char *inbuf) | |
707 | { | |
708 | LOCAL_ARRAY(char, buf, DNS_INBUF_SZ); | |
709 | char *token; | |
710 | ! static ipcache_entry i; | |
711 | ! int j; | |
712 | int k; | |
713 | int ipcount = 0; | |
714 | int ttl; | |
715 | char A[32][16]; | |
716 | ! memset(&i, '\0', sizeof(i)); | |
717 | ! i.expires = squid_curtime; | |
718 | ! i.flags.negcached = 1; | |
719 | if (inbuf == NULL) { | |
720 | debug(14, 1) ("ipcacheParse: Got <NULL> reply\n"); | |
721 | ! i.error_message = xstrdup("Internal Squid Error"); | |
722 | ! return &i; | |
723 | } | |
724 | xstrncpy(buf, inbuf, DNS_INBUF_SZ); | |
725 | debug(14, 5) ("ipcacheParse: parsing: {%s}\n", buf); | |
726 | token = strtok(buf, w_space); | |
727 | if (NULL == token) { | |
728 | ! debug(14, 1) ("ipcacheParse: Got <NULL>, expecting '$addr'\n"); | |
729 | ! return &i; | |
730 | } | |
731 | if (0 == strcmp(token, "$fail")) { | |
732 | - i.expires = squid_curtime + Config.negativeDnsTtl; | |
733 | token = strtok(NULL, "\n"); | |
734 | assert(NULL != token); | |
735 | ! i.error_message = xstrdup(token); | |
736 | ! return &i; | |
737 | } | |
738 | if (0 != strcmp(token, "$addr")) { | |
739 | ! debug(14, 1) ("ipcacheParse: Got '%s', expecting '$addr'\n", token); | |
740 | ! return &i; | |
741 | } | |
742 | token = strtok(NULL, w_space); | |
743 | if (NULL == token) { | |
744 | ! debug(14, 1) ("ipcacheParse: Got <NULL>, expecting TTL\n"); | |
745 | ! return &i; | |
746 | } | |
747 | ! i.flags.negcached = 0; | |
748 | ttl = atoi(token); | |
749 | - if (ttl > 0 && ttl < Config.positiveDnsTtl) | |
750 | - i.expires = squid_curtime + ttl; | |
751 | - else | |
752 | - i.expires = squid_curtime + Config.positiveDnsTtl; | |
753 | while (NULL != (token = strtok(NULL, w_space))) { | |
754 | xstrncpy(A[ipcount], token, 16); | |
755 | if (++ipcount == 32) | |
756 | break; | |
757 | } | |
758 | ! if (0 == ipcount) { | |
759 | ! i.addrs.in_addrs = NULL; | |
760 | ! i.addrs.bad_mask = NULL; | |
761 | } else { | |
762 | ! i.addrs.in_addrs = xcalloc(ipcount, sizeof(struct in_addr)); | |
763 | ! i.addrs.bad_mask = xcalloc(ipcount, sizeof(unsigned char)); | |
764 | ! } | |
765 | ! for (j = 0, k = 0; k < ipcount; k++) { | |
766 | ! if (safe_inet_addr(A[k], &i.addrs.in_addrs[j])) | |
767 | ! j++; | |
768 | ! else | |
769 | ! debug(14, 1) ("ipcacheParse: Invalid IP address '%s'\n", A[k]); | |
770 | } | |
771 | ! i.addrs.count = (unsigned char) j; | |
772 | ! return &i; | |
773 | } | |
774 | #else | |
775 | ! ipcacheParse(rfc1035_rr * answers, int nr) | |
776 | { | |
777 | - static ipcache_entry i; | |
778 | int k; | |
779 | int j; | |
780 | int na = 0; | |
781 | ! memset(&i, '\0', sizeof(i)); | |
782 | ! i.expires = squid_curtime + Config.negativeDnsTtl; | |
783 | ! i.flags.negcached = 1; | |
784 | if (nr < 0) { | |
785 | ! debug(14, 3) ("ipcacheParse: Lookup failed (error %d)\n", | |
786 | ! rfc1035_errno); | |
787 | ! assert(rfc1035_error_message); | |
788 | ! i.error_message = xstrdup(rfc1035_error_message); | |
789 | ! return &i; | |
790 | } | |
791 | if (nr == 0) { | |
792 | ! debug(14, 3) ("ipcacheParse: No DNS records\n"); | |
793 | ! i.error_message = xstrdup("No DNS records"); | |
794 | ! return &i; | |
795 | } | |
796 | assert(answers); | |
797 | for (j = 0, k = 0; k < nr; k++) { | |
798 | --- 234,339 ---- | |
799 | ipcacheUnlockEntry(i); | |
800 | } | |
801 | ||
802 | #if USE_DNSSERVERS | |
803 | ! static ipcache_entry * | |
804 | ! ipcacheParse(ipcache_entry * i, const char *inbuf) | |
805 | { | |
806 | LOCAL_ARRAY(char, buf, DNS_INBUF_SZ); | |
807 | char *token; | |
808 | ! int j = 0; | |
809 | int k; | |
810 | int ipcount = 0; | |
811 | int ttl; | |
812 | char A[32][16]; | |
813 | ! const char *name = (const char *) i->hash.key; | |
814 | ! i->expires = squid_curtime + Config.negativeDnsTtl; | |
815 | ! i->flags.negcached = 1; | |
816 | ! safe_free(i->addrs.in_addrs); | |
817 | ! safe_free(i->addrs.bad_mask); | |
818 | ! safe_free(i->error_message); | |
819 | ! i->addrs.count = 0; | |
820 | if (inbuf == NULL) { | |
821 | debug(14, 1) ("ipcacheParse: Got <NULL> reply\n"); | |
822 | ! i->error_message = xstrdup("Internal Squid Error"); | |
823 | ! return i; | |
824 | } | |
825 | xstrncpy(buf, inbuf, DNS_INBUF_SZ); | |
826 | debug(14, 5) ("ipcacheParse: parsing: {%s}\n", buf); | |
827 | token = strtok(buf, w_space); | |
828 | if (NULL == token) { | |
829 | ! debug(14, 1) ("ipcacheParse: expecting result, got '%s'\n", inbuf); | |
830 | ! i->error_message = xstrdup("Internal Squid Error"); | |
831 | ! return NULL; | |
832 | } | |
833 | if (0 == strcmp(token, "$fail")) { | |
834 | token = strtok(NULL, "\n"); | |
835 | assert(NULL != token); | |
836 | ! i->error_message = xstrdup(token); | |
837 | ! return i; | |
838 | } | |
839 | if (0 != strcmp(token, "$addr")) { | |
840 | ! debug(14, 1) ("ipcacheParse: expecting '$addr', got '%s' in response to '%s'\n", inbuf, name); | |
841 | ! i->error_message = xstrdup("Internal Squid Error"); | |
842 | ! return NULL; | |
843 | } | |
844 | token = strtok(NULL, w_space); | |
845 | if (NULL == token) { | |
846 | ! debug(14, 1) ("ipcacheParse: expecting data, got '%s' in response to '%s'\n", inbuf, name); | |
847 | ! i->error_message = xstrdup("Internal Squid Error"); | |
848 | ! return NULL; | |
849 | } | |
850 | ! i->flags.negcached = 0; | |
851 | ttl = atoi(token); | |
852 | while (NULL != (token = strtok(NULL, w_space))) { | |
853 | xstrncpy(A[ipcount], token, 16); | |
854 | if (++ipcount == 32) | |
855 | break; | |
856 | } | |
857 | ! if (ipcount <= 0) { | |
858 | ! debug(14, 1) ("ipcacheParse: No addresses in response to '%s'\n", name); | |
859 | } else { | |
860 | ! i->addrs.in_addrs = xcalloc(ipcount, sizeof(struct in_addr)); | |
861 | ! i->addrs.bad_mask = xcalloc(ipcount, sizeof(unsigned char)); | |
862 | ! for (j = 0, k = 0; k < ipcount; k++) { | |
863 | ! if (safe_inet_addr(A[k], &i->addrs.in_addrs[j])) | |
864 | ! j++; | |
865 | ! else | |
866 | ! debug(14, 1) ("ipcacheParse: Invalid IP address '%s' in response to '%s'\n", A[k], name); | |
867 | ! } | |
868 | } | |
869 | ! i->addrs.count = (unsigned char) j; | |
870 | ! if (ttl == 0 || ttl > Config.positiveDnsTtl) | |
871 | ! ttl = Config.positiveDnsTtl; | |
872 | ! if (ttl < Config.negativeDnsTtl) | |
873 | ! ttl = Config.negativeDnsTtl; | |
874 | ! i->expires = squid_curtime + ttl; | |
875 | ! return i; | |
876 | } | |
877 | #else | |
878 | ! static ipcache_entry * | |
879 | ! ipcacheParse(ipcache_entry * i, rfc1035_rr * answers, int nr, const char *error_message) | |
880 | { | |
881 | int k; | |
882 | int j; | |
883 | int na = 0; | |
884 | ! int ttl = 0; | |
885 | ! const char *name = (const char *) i->hash.key; | |
886 | ! i->expires = squid_curtime + Config.negativeDnsTtl; | |
887 | ! i->flags.negcached = 1; | |
888 | ! safe_free(i->addrs.in_addrs); | |
889 | ! safe_free(i->addrs.bad_mask); | |
890 | ! safe_free(i->error_message); | |
891 | ! i->addrs.count = 0; | |
892 | if (nr < 0) { | |
893 | ! debug(14, 3) ("ipcacheParse: Lookup failed '%s' for '%s'\n", | |
894 | ! error_message, (const char *) i->hash.key); | |
895 | ! i->error_message = xstrdup(error_message); | |
896 | ! return i; | |
897 | } | |
898 | if (nr == 0) { | |
899 | ! debug(14, 3) ("ipcacheParse: No DNS records in response to '%s'\n", name); | |
900 | ! i->error_message = xstrdup("No DNS records"); | |
901 | ! return i; | |
902 | } | |
903 | assert(answers); | |
904 | for (j = 0, k = 0; k < nr; k++) { | |
905 | *************** | |
906 | *** 331,363 **** | |
907 | na++; | |
908 | } | |
909 | if (na == 0) { | |
910 | ! debug(14, 1) ("ipcacheParse: No Address records\n"); | |
911 | ! i.error_message = xstrdup("No Address records"); | |
912 | ! return &i; | |
913 | ! } | |
914 | ! i.flags.negcached = 0; | |
915 | ! i.addrs.in_addrs = xcalloc(na, sizeof(struct in_addr)); | |
916 | ! i.addrs.bad_mask = xcalloc(na, sizeof(unsigned char)); | |
917 | ! i.addrs.count = (unsigned char) na; | |
918 | for (j = 0, k = 0; k < nr; k++) { | |
919 | if (answers[k].type != RFC1035_TYPE_A) | |
920 | continue; | |
921 | if (answers[k].class != RFC1035_CLASS_IN) | |
922 | continue; | |
923 | ! if (j == 0) { | |
924 | ! if (answers[k].ttl < Config.positiveDnsTtl) | |
925 | ! i.expires = squid_curtime + answers[k].ttl; | |
926 | ! else | |
927 | ! i.expires = squid_curtime + Config.positiveDnsTtl; | |
928 | ! } | |
929 | assert(answers[k].rdlength == 4); | |
930 | ! xmemcpy(&i.addrs.in_addrs[j++], answers[k].rdata, 4); | |
931 | debug(14, 3) ("ipcacheParse: #%d %s\n", | |
932 | j - 1, | |
933 | ! inet_ntoa(i.addrs.in_addrs[j - 1])); | |
934 | } | |
935 | assert(j == na); | |
936 | ! return &i; | |
937 | } | |
938 | #endif | |
939 | ||
940 | --- 344,377 ---- | |
941 | na++; | |
942 | } | |
943 | if (na == 0) { | |
944 | ! debug(14, 1) ("ipcacheParse: No Address records in response to '%s'\n", name); | |
945 | ! i->error_message = xstrdup("No Address records"); | |
946 | ! return i; | |
947 | ! } | |
948 | ! i->flags.negcached = 0; | |
949 | ! i->addrs.in_addrs = xcalloc(na, sizeof(struct in_addr)); | |
950 | ! i->addrs.bad_mask = xcalloc(na, sizeof(unsigned char)); | |
951 | for (j = 0, k = 0; k < nr; k++) { | |
952 | if (answers[k].type != RFC1035_TYPE_A) | |
953 | continue; | |
954 | if (answers[k].class != RFC1035_CLASS_IN) | |
955 | continue; | |
956 | ! if (ttl == 0 || ttl > answers[k].ttl) | |
957 | ! ttl = answers[k].ttl; | |
958 | assert(answers[k].rdlength == 4); | |
959 | ! xmemcpy(&i->addrs.in_addrs[j++], answers[k].rdata, 4); | |
960 | debug(14, 3) ("ipcacheParse: #%d %s\n", | |
961 | j - 1, | |
962 | ! inet_ntoa(i->addrs.in_addrs[j - 1])); | |
963 | } | |
964 | + i->addrs.count = (unsigned char) na; | |
965 | + if (ttl == 0 || ttl > Config.positiveDnsTtl) | |
966 | + ttl = Config.positiveDnsTtl; | |
967 | + if (ttl < Config.negativeDnsTtl) | |
968 | + ttl = Config.negativeDnsTtl; | |
969 | + i->expires = squid_curtime + ttl; | |
970 | assert(j == na); | |
971 | ! return i; | |
972 | } | |
973 | #endif | |
974 | ||
975 | *************** | |
976 | *** 365,391 **** | |
977 | #if USE_DNSSERVERS | |
978 | ipcacheHandleReply(void *data, char *reply) | |
979 | #else | |
980 | ! ipcacheHandleReply(void *data, rfc1035_rr * answers, int na) | |
981 | #endif | |
982 | { | |
983 | generic_cbdata *c = data; | |
984 | ipcache_entry *i = c->data; | |
985 | - ipcache_entry *x = NULL; | |
986 | cbdataFree(c); | |
987 | c = NULL; | |
988 | IpcacheStats.replies++; | |
989 | statHistCount(&statCounter.dns.svc_time, | |
990 | tvSubMsec(i->request_time, current_time)); | |
991 | #if USE_DNSSERVERS | |
992 | ! x = ipcacheParse(reply); | |
993 | #else | |
994 | ! x = ipcacheParse(answers, na); | |
995 | #endif | |
996 | - assert(x); | |
997 | - i->addrs = x->addrs; | |
998 | - i->error_message = x->error_message; | |
999 | - i->expires = x->expires; | |
1000 | - i->flags = x->flags; | |
1001 | ipcacheAddEntry(i); | |
1002 | ipcacheCallback(i); | |
1003 | } | |
1004 | --- 379,399 ---- | |
1005 | #if USE_DNSSERVERS | |
1006 | ipcacheHandleReply(void *data, char *reply) | |
1007 | #else | |
1008 | ! ipcacheHandleReply(void *data, rfc1035_rr * answers, int na, const char *error_message) | |
1009 | #endif | |
1010 | { | |
1011 | generic_cbdata *c = data; | |
1012 | ipcache_entry *i = c->data; | |
1013 | cbdataFree(c); | |
1014 | c = NULL; | |
1015 | IpcacheStats.replies++; | |
1016 | statHistCount(&statCounter.dns.svc_time, | |
1017 | tvSubMsec(i->request_time, current_time)); | |
1018 | #if USE_DNSSERVERS | |
1019 | ! ipcacheParse(i, reply); | |
1020 | #else | |
1021 | ! ipcacheParse(i, answers, na, error_message); | |
1022 | #endif | |
1023 | ipcacheAddEntry(i); | |
1024 | ipcacheCallback(i); | |
1025 | } | |
1026 | Index: squid/src/structs.h | |
1027 | diff -c squid/src/structs.h:1.408.2.16 squid/src/structs.h:1.408.2.17 | |
1028 | *** squid/src/structs.h:1.408.2.16 Sat Nov 29 11:53:00 2003 | |
1029 | --- squid/src/structs.h Sat Dec 6 10:19:38 2003 | |
1030 | *************** | |
1031 | *** 400,405 **** | |
1032 | --- 400,406 ---- | |
1033 | struct { | |
1034 | time_t read; | |
1035 | time_t lifetime; | |
1036 | + time_t forward; | |
1037 | time_t connect; | |
1038 | time_t peer_connect; | |
1039 | time_t request; | |
1040 | Index: squid/src/typedefs.h | |
1041 | diff -c squid/src/typedefs.h:1.132.2.2 squid/src/typedefs.h:1.132.2.3 | |
1042 | *** squid/src/typedefs.h:1.132.2.2 Sun May 11 11:30:13 2003 | |
1043 | --- squid/src/typedefs.h Sat Dec 6 10:19:38 2003 | |
1044 | *************** | |
1045 | *** 253,259 **** | |
1046 | typedef int HLPSAVAIL(void *); | |
1047 | typedef void HLPSONEQ(void *); | |
1048 | typedef void HLPCMDOPTS(int *argc, char **argv); | |
1049 | ! typedef void IDNSCB(void *, rfc1035_rr *, int); | |
1050 | ||
1051 | typedef void STINIT(SwapDir *); | |
1052 | typedef void STNEWFS(SwapDir *); | |
1053 | --- 253,259 ---- | |
1054 | typedef int HLPSAVAIL(void *); | |
1055 | typedef void HLPSONEQ(void *); | |
1056 | typedef void HLPCMDOPTS(int *argc, char **argv); | |
1057 | ! typedef void IDNSCB(void *, rfc1035_rr *, int, const char *); | |
1058 | ||
1059 | typedef void STINIT(SwapDir *); | |
1060 | typedef void STNEWFS(SwapDir *); |