source: branches/samba-3.2.x/source/nmbd/asyncdns.c@ 198

Last change on this file since 198 was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 10.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 a async DNS handler
4 Copyright (C) Andrew Tridgell 1997-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include "includes.h"
21
22/***************************************************************************
23 Add a DNS result to the name cache.
24****************************************************************************/
25
26static struct name_record *add_dns_result(struct nmb_name *question, struct in_addr addr)
27{
28 int name_type = question->name_type;
29 unstring qname;
30
31 pull_ascii_nstring(qname, sizeof(qname), question->name);
32
33 if (!addr.s_addr) {
34 /* add the fail to WINS cache of names. give it 1 hour in the cache */
35 DEBUG(3,("add_dns_result: Negative DNS answer for %s\n", qname));
36 add_name_to_subnet( wins_server_subnet, qname, name_type,
37 NB_ACTIVE, 60*60, DNSFAIL_NAME, 1, &addr );
38 return NULL;
39 }
40
41 /* add it to our WINS cache of names. give it 2 hours in the cache */
42 DEBUG(3,("add_dns_result: DNS gave answer for %s of %s\n", qname, inet_ntoa(addr)));
43
44 add_name_to_subnet( wins_server_subnet, qname, name_type,
45 NB_ACTIVE, 2*60*60, DNS_NAME, 1, &addr);
46
47 return find_name_on_subnet(wins_server_subnet, question, FIND_ANY_NAME);
48}
49
50#ifndef SYNC_DNS
51
52static int fd_in = -1, fd_out = -1;
53static pid_t child_pid = -1;
54static int in_dns;
55
56/* this is the structure that is passed between the parent and child */
57struct query_record {
58 struct nmb_name name;
59 struct in_addr result;
60};
61
62/* a queue of pending requests waiting to be sent to the DNS child */
63static struct packet_struct *dns_queue;
64
65/* the packet currently being processed by the dns child */
66static struct packet_struct *dns_current;
67
68
69/***************************************************************************
70 return the fd used to gather async dns replies. This is added to the select
71 loop
72 ****************************************************************************/
73
74int asyncdns_fd(void)
75{
76 return fd_in;
77}
78
79/***************************************************************************
80 handle DNS queries arriving from the parent
81 ****************************************************************************/
82static void asyncdns_process(void)
83{
84 struct query_record r;
85 unstring qname;
86
87 DEBUGLEVEL = -1;
88
89 while (1) {
90 NTSTATUS status;
91
92 status = read_data(fd_in, (char *)&r, sizeof(r));
93
94 if (!NT_STATUS_IS_OK(status)) {
95 break;
96 }
97
98 pull_ascii_nstring( qname, sizeof(qname), r.name.name);
99 r.result.s_addr = interpret_addr(qname);
100
101 if (write_data(fd_out, (char *)&r, sizeof(r)) != sizeof(r))
102 break;
103 }
104
105 _exit(0);
106}
107
108/**************************************************************************** **
109 catch a sigterm (in the child process - the parent has a different handler
110 see nmbd.c for details).
111 We need a separate term handler here so we don't release any
112 names that our parent is going to release, or overwrite a
113 WINS db that our parent is going to write.
114 **************************************************************************** */
115
116static void sig_term(int sig)
117{
118 _exit(0);
119}
120
121/***************************************************************************
122 Called by the parent process when it receives a SIGTERM - also kills the
123 child so we don't get child async dns processes lying around, causing trouble.
124 ****************************************************************************/
125
126void kill_async_dns_child(void)
127{
128 if (child_pid > 0) {
129 kill(child_pid, SIGTERM);
130 child_pid = -1;
131 }
132}
133
134/***************************************************************************
135 create a child process to handle DNS lookups
136 ****************************************************************************/
137void start_async_dns(void)
138{
139 int fd1[2], fd2[2];
140
141 CatchChild();
142#ifdef __OS2__
143// cant use pipes here, because select() from innotek lib does work only for sockets.
144 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd1) < 0)
145 {
146 DEBUG(0,("can't create asyncdns socketpair1 %d\n", errno));
147 return;
148 }
149 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd2) < 0)
150 {
151 DEBUG(0,("can't create asyncdns socketpair2 %d\n", errno));
152 close(fd1[0]);
153 close(fd1[1]);
154 return;
155 }
156DEBUG(9,("!!!!!!PIPES %d %d %d %d\n", fd1[0], fd1[1], fd2[0], fd2[1]));
157#else
158 if (pipe(fd1) || pipe(fd2)) {
159 DEBUG(0,("can't create asyncdns pipes\n"));
160 return;
161 }
162#endif /* __OS2__ */
163 child_pid = sys_fork();
164
165 if (child_pid) {
166 fd_in = fd1[0];
167 fd_out = fd2[1];
168 close(fd1[1]);
169 close(fd2[0]);
170 DEBUG(0,("started asyncdns process %d\n", (int)child_pid));
171 return;
172 }
173
174 fd_in = fd2[0];
175 fd_out = fd1[1];
176
177 CatchSignal(SIGUSR2, SIG_IGN);
178 CatchSignal(SIGUSR1, SIG_IGN);
179 CatchSignal(SIGHUP, SIG_IGN);
180 CatchSignal(SIGTERM, SIGNAL_CAST sig_term );
181
182 if (!reinit_after_fork(nmbd_messaging_context(), true)) {
183 DEBUG(0,("reinit_after_fork() failed\n"));
184 smb_panic("reinit_after_fork() failed");
185 }
186
187 asyncdns_process();
188}
189
190
191/***************************************************************************
192check if a particular name is already being queried
193 ****************************************************************************/
194static bool query_current(struct query_record *r)
195{
196 return dns_current &&
197 nmb_name_equal(&r->name,
198 &dns_current->packet.nmb.question.question_name);
199}
200
201
202/***************************************************************************
203 write a query to the child process
204 ****************************************************************************/
205static bool write_child(struct packet_struct *p)
206{
207 struct query_record r;
208
209 r.name = p->packet.nmb.question.question_name;
210
211 return write_data(fd_out, (char *)&r, sizeof(r)) == sizeof(r);
212}
213
214/***************************************************************************
215 check the DNS queue
216 ****************************************************************************/
217void run_dns_queue(void)
218{
219 struct query_record r;
220 struct packet_struct *p, *p2;
221 struct name_record *namerec;
222 NTSTATUS status;
223
224 if (fd_in == -1)
225 return;
226
227 /* Allow SIGTERM to kill us. */
228 BlockSignals(False, SIGTERM);
229
230 if (!process_exists_by_pid(child_pid)) {
231 close(fd_in);
232 close(fd_out);
233 start_async_dns();
234 }
235
236 status = read_data(fd_in, (char *)&r, sizeof(r));
237
238 if (!NT_STATUS_IS_OK(status)) {
239 DEBUG(0, ("read from child failed: %s\n", nt_errstr(status)));
240 fd_in = -1;
241 BlockSignals(True, SIGTERM);
242 return;
243 }
244
245 BlockSignals(True, SIGTERM);
246
247 namerec = add_dns_result(&r.name, r.result);
248
249 if (dns_current) {
250 if (query_current(&r)) {
251 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
252 in_dns = 1;
253 if(namerec == NULL)
254 send_wins_name_query_response(NAM_ERR, dns_current, NULL);
255 else
256 send_wins_name_query_response(0,dns_current,namerec);
257 in_dns = 0;
258 }
259
260 dns_current->locked = False;
261 free_packet(dns_current);
262 dns_current = NULL;
263 }
264
265 /* loop over the whole dns queue looking for entries that
266 match the result we just got */
267 for (p = dns_queue; p;) {
268 struct nmb_packet *nmb = &p->packet.nmb;
269 struct nmb_name *question = &nmb->question.question_name;
270
271 if (nmb_name_equal(question, &r.name)) {
272 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
273 in_dns = 1;
274 if(namerec == NULL)
275 send_wins_name_query_response(NAM_ERR, p, NULL);
276 else
277 send_wins_name_query_response(0,p,namerec);
278 in_dns = 0;
279 p->locked = False;
280
281 if (p->prev)
282 p->prev->next = p->next;
283 else
284 dns_queue = p->next;
285 if (p->next)
286 p->next->prev = p->prev;
287 p2 = p->next;
288 free_packet(p);
289 p = p2;
290 } else {
291 p = p->next;
292 }
293 }
294
295 if (dns_queue) {
296 dns_current = dns_queue;
297 dns_queue = dns_queue->next;
298 if (dns_queue)
299 dns_queue->prev = NULL;
300 dns_current->next = NULL;
301
302 if (!write_child(dns_current)) {
303 DEBUG(3,("failed to send DNS query to child!\n"));
304 return;
305 }
306 }
307}
308
309/***************************************************************************
310queue a DNS query
311 ****************************************************************************/
312
313bool queue_dns_query(struct packet_struct *p,struct nmb_name *question)
314{
315 if (in_dns || fd_in == -1)
316 return False;
317
318 if (!dns_current) {
319 if (!write_child(p)) {
320 DEBUG(3,("failed to send DNS query to child!\n"));
321 return False;
322 }
323 dns_current = p;
324 p->locked = True;
325 } else {
326 p->locked = True;
327 p->next = dns_queue;
328 p->prev = NULL;
329 if (p->next)
330 p->next->prev = p;
331 dns_queue = p;
332 }
333
334 DEBUG(3,("added DNS query for %s\n", nmb_namestr(question)));
335 return True;
336}
337
338#else
339
340
341/***************************************************************************
342 we use this when we can't do async DNS lookups
343 ****************************************************************************/
344
345bool queue_dns_query(struct packet_struct *p,struct nmb_name *question)
346{
347 struct name_record *namerec = NULL;
348 struct in_addr dns_ip;
349 unstring qname;
350
351 pull_ascii_nstring(qname, sizeof(qname), question->name);
352
353 DEBUG(3,("DNS search for %s - ", nmb_namestr(question)));
354
355 /* Unblock TERM signal so we can be killed in DNS lookup. */
356 BlockSignals(False, SIGTERM);
357
358 dns_ip.s_addr = interpret_addr(qname);
359
360 /* Re-block TERM signal. */
361 BlockSignals(True, SIGTERM);
362
363 namerec = add_dns_result(question, dns_ip);
364 if(namerec == NULL) {
365 send_wins_name_query_response(NAM_ERR, p, NULL);
366 } else {
367 send_wins_name_query_response(0, p, namerec);
368 }
369 return False;
370}
371
372/***************************************************************************
373 With sync dns there is no child to kill on SIGTERM.
374 ****************************************************************************/
375
376void kill_async_dns_child(void)
377{
378 return;
379}
380#endif
Note: See TracBrowser for help on using the repository browser.