2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1997-1998
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 2 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 /***************************************************************************
24 Add a DNS result to the name cache.
25 ****************************************************************************/
27 static struct name_record
*add_dns_result(struct nmb_name
*question
, struct in_addr addr
)
29 int name_type
= question
->name_type
;
32 pull_ascii_nstring(qname
, sizeof(qname
), question
->name
);
35 /* add the fail to WINS cache of names. give it 1 hour in the cache */
36 DEBUG(3,("add_dns_result: Negative DNS answer for %s\n", qname
));
37 add_name_to_subnet( wins_server_subnet
, qname
, name_type
,
38 NB_ACTIVE
, 60*60, DNSFAIL_NAME
, 1, &addr
);
42 /* add it to our WINS cache of names. give it 2 hours in the cache */
43 DEBUG(3,("add_dns_result: DNS gave answer for %s of %s\n", qname
, inet_ntoa(addr
)));
45 add_name_to_subnet( wins_server_subnet
, qname
, name_type
,
46 NB_ACTIVE
, 2*60*60, DNS_NAME
, 1, &addr
);
48 return find_name_on_subnet(wins_server_subnet
, question
, FIND_ANY_NAME
);
53 static int fd_in
= -1, fd_out
= -1;
54 static pid_t child_pid
= -1;
57 /* this is the structure that is passed between the parent and child */
60 struct in_addr result
;
63 /* a queue of pending requests waiting to be sent to the DNS child */
64 static struct packet_struct
*dns_queue
;
66 /* the packet currently being processed by the dns child */
67 static struct packet_struct
*dns_current
;
70 /***************************************************************************
71 return the fd used to gather async dns replies. This is added to the select
73 ****************************************************************************/
80 /***************************************************************************
81 handle DNS queries arriving from the parent
82 ****************************************************************************/
83 static void asyncdns_process(void)
85 struct query_record r
;
91 if (read_data(fd_in
, (char *)&r
, sizeof(r
)) != sizeof(r
))
94 pull_ascii_nstring( qname
, sizeof(qname
), r
.name
.name
);
95 r
.result
.s_addr
= interpret_addr(qname
);
97 if (write_data(fd_out
, (char *)&r
, sizeof(r
)) != sizeof(r
))
104 /**************************************************************************** **
105 catch a sigterm (in the child process - the parent has a different handler
106 see nmbd.c for details).
107 We need a separate term handler here so we don't release any
108 names that our parent is going to release, or overwrite a
109 WINS db that our parent is going to write.
110 **************************************************************************** */
112 static void sig_term(int sig
)
117 /***************************************************************************
118 Called by the parent process when it receives a SIGTERM - also kills the
119 child so we don't get child async dns processes lying around, causing trouble.
120 ****************************************************************************/
122 void kill_async_dns_child(void)
125 kill(child_pid
, SIGTERM
);
130 /***************************************************************************
131 create a child process to handle DNS lookups
132 ****************************************************************************/
133 void start_async_dns(void)
139 if (pipe(fd1
) || pipe(fd2
)) {
140 DEBUG(0,("can't create asyncdns pipes\n"));
144 child_pid
= sys_fork();
151 DEBUG(0,("started asyncdns process %d\n", (int)child_pid
));
158 CatchSignal(SIGUSR2
, SIG_IGN
);
159 CatchSignal(SIGUSR1
, SIG_IGN
);
160 CatchSignal(SIGHUP
, SIG_IGN
);
161 CatchSignal(SIGTERM
, SIGNAL_CAST sig_term
);
167 /***************************************************************************
168 check if a particular name is already being queried
169 ****************************************************************************/
170 static BOOL
query_current(struct query_record
*r
)
172 return dns_current
&&
173 nmb_name_equal(&r
->name
,
174 &dns_current
->packet
.nmb
.question
.question_name
);
178 /***************************************************************************
179 write a query to the child process
180 ****************************************************************************/
181 static BOOL
write_child(struct packet_struct
*p
)
183 struct query_record r
;
185 r
.name
= p
->packet
.nmb
.question
.question_name
;
187 return write_data(fd_out
, (char *)&r
, sizeof(r
)) == sizeof(r
);
190 /***************************************************************************
192 ****************************************************************************/
193 void run_dns_queue(void)
195 struct query_record r
;
196 struct packet_struct
*p
, *p2
;
197 struct name_record
*namerec
;
203 /* Allow SIGTERM to kill us. */
204 BlockSignals(False
, SIGTERM
);
206 if (!process_exists_by_pid(child_pid
)) {
212 if ((size
=read_data(fd_in
, (char *)&r
, sizeof(r
))) != sizeof(r
)) {
214 DEBUG(0,("Incomplete DNS answer from child!\n"));
217 BlockSignals(True
, SIGTERM
);
221 BlockSignals(True
, SIGTERM
);
223 namerec
= add_dns_result(&r
.name
, r
.result
);
226 if (query_current(&r
)) {
227 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
230 send_wins_name_query_response(NAM_ERR
, dns_current
, NULL
);
232 send_wins_name_query_response(0,dns_current
,namerec
);
236 dns_current
->locked
= False
;
237 free_packet(dns_current
);
241 /* loop over the whole dns queue looking for entries that
242 match the result we just got */
243 for (p
= dns_queue
; p
;) {
244 struct nmb_packet
*nmb
= &p
->packet
.nmb
;
245 struct nmb_name
*question
= &nmb
->question
.question_name
;
247 if (nmb_name_equal(question
, &r
.name
)) {
248 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
251 send_wins_name_query_response(NAM_ERR
, p
, NULL
);
253 send_wins_name_query_response(0,p
,namerec
);
258 p
->prev
->next
= p
->next
;
262 p
->next
->prev
= p
->prev
;
272 dns_current
= dns_queue
;
273 dns_queue
= dns_queue
->next
;
275 dns_queue
->prev
= NULL
;
276 dns_current
->next
= NULL
;
278 if (!write_child(dns_current
)) {
279 DEBUG(3,("failed to send DNS query to child!\n"));
285 /***************************************************************************
287 ****************************************************************************/
289 BOOL
queue_dns_query(struct packet_struct
*p
,struct nmb_name
*question
)
291 if (in_dns
|| fd_in
== -1)
295 if (!write_child(p
)) {
296 DEBUG(3,("failed to send DNS query to child!\n"));
310 DEBUG(3,("added DNS query for %s\n", nmb_namestr(question
)));
317 /***************************************************************************
318 we use this when we can't do async DNS lookups
319 ****************************************************************************/
321 BOOL
queue_dns_query(struct packet_struct
*p
,struct nmb_name
*question
)
323 struct name_record
*namerec
= NULL
;
324 struct in_addr dns_ip
;
327 pull_ascii_nstring(qname
, sizeof(qname
), question
->name
);
329 DEBUG(3,("DNS search for %s - ", nmb_namestr(question
)));
331 /* Unblock TERM signal so we can be killed in DNS lookup. */
332 BlockSignals(False
, SIGTERM
);
334 dns_ip
.s_addr
= interpret_addr(qname
);
336 /* Re-block TERM signal. */
337 BlockSignals(True
, SIGTERM
);
339 namerec
= add_dns_result(question
, dns_ip
);
340 if(namerec
== NULL
) {
341 send_wins_name_query_response(NAM_ERR
, p
, NULL
);
343 send_wins_name_query_response(0, p
, namerec
);
348 /***************************************************************************
349 With sync dns there is no child to kill on SIGTERM.
350 ****************************************************************************/
352 void kill_async_dns_child(void)