2 Unix SMB/Netbios 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
;
30 char *qname
= question
->name
;
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 (void)add_name_to_subnet( wins_server_subnet
, qname
, name_type
,
37 NB_ACTIVE
, 60*60, DNSFAIL_NAME
, 1, &addr
);
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
)));
44 return( add_name_to_subnet( wins_server_subnet
, qname
, name_type
,
45 NB_ACTIVE
, 2*60*60, DNS_NAME
, 1, &addr
) );
52 static int fd_in
= -1, fd_out
= -1;
53 static pid_t child_pid
= -1;
56 /* this is the structure that is passed between the parent and child */
59 struct in_addr result
;
62 /* a queue of pending requests waiting to be sent to the DNS child */
63 static struct packet_struct
*dns_queue
;
65 /* the packet currently being processed by the dns child */
66 static struct packet_struct
*dns_current
;
69 /***************************************************************************
70 return the fd used to gather async dns replies. This is added to the select
72 ****************************************************************************/
78 /***************************************************************************
79 handle DNS queries arriving from the parent
80 ****************************************************************************/
81 static void asyncdns_process(void)
83 struct query_record r
;
89 if (read_data(fd_in
, (char *)&r
, sizeof(r
)) != sizeof(r
))
92 fstrcpy(qname
, r
.name
.name
);
94 r
.result
.s_addr
= interpret_addr(qname
);
96 if (write_data(fd_out
, (char *)&r
, sizeof(r
)) != sizeof(r
))
103 /**************************************************************************** **
104 catch a sigterm (in the child process - the parent has a different handler
105 see nmbd.c for details).
106 We need a separate term handler here so we don't release any
107 names that our parent is going to release, or overwrite a
108 WINS db that our parent is going to write.
109 **************************************************************************** */
111 static void sig_term(int sig
)
116 /***************************************************************************
117 Called by the parent process when it receives a SIGTERM - also kills the
118 child so we don't get child async dns processes lying around, causing trouble.
119 ****************************************************************************/
121 void kill_async_dns_child(void)
123 if(child_pid
!= 0 && child_pid
!= -1)
124 kill(child_pid
, SIGTERM
);
127 /***************************************************************************
128 create a child process to handle DNS lookups
129 ****************************************************************************/
130 void start_async_dns(void)
136 if (pipe(fd1
) || pipe(fd2
)) {
137 DEBUG(0,("can't create asyncdns pipes\n"));
141 child_pid
= sys_fork();
148 DEBUG(0,("started asyncdns process %d\n", (int)child_pid
));
155 CatchSignal(SIGUSR2
, SIG_IGN
);
156 CatchSignal(SIGUSR1
, SIG_IGN
);
157 CatchSignal(SIGHUP
, SIG_IGN
);
158 CatchSignal(SIGTERM
, SIGNAL_CAST sig_term
);
164 /***************************************************************************
165 check if a particular name is already being queried
166 ****************************************************************************/
167 static BOOL
query_current(struct query_record
*r
)
169 return dns_current
&&
170 nmb_name_equal(&r
->name
,
171 &dns_current
->packet
.nmb
.question
.question_name
);
175 /***************************************************************************
176 write a query to the child process
177 ****************************************************************************/
178 static BOOL
write_child(struct packet_struct
*p
)
180 struct query_record r
;
182 r
.name
= p
->packet
.nmb
.question
.question_name
;
184 return write_data(fd_out
, (char *)&r
, sizeof(r
)) == sizeof(r
);
187 /***************************************************************************
189 ****************************************************************************/
190 void run_dns_queue(void)
192 struct query_record r
;
193 struct packet_struct
*p
, *p2
;
194 struct name_record
*namerec
;
200 /* Allow SIGTERM to kill us. */
201 BlockSignals(False
, SIGTERM
);
203 if (!process_exists(child_pid
)) {
208 if ((size
=read_data(fd_in
, (char *)&r
, sizeof(r
))) != sizeof(r
)) {
210 DEBUG(0,("Incomplete DNS answer from child!\n"));
213 BlockSignals(True
, SIGTERM
);
217 BlockSignals(True
, SIGTERM
);
219 namerec
= add_dns_result(&r
.name
, r
.result
);
222 if (query_current(&r
)) {
223 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
226 send_wins_name_query_response(NAM_ERR
, dns_current
, NULL
);
228 send_wins_name_query_response(0,dns_current
,namerec
);
232 dns_current
->locked
= False
;
233 free_packet(dns_current
);
237 /* loop over the whole dns queue looking for entries that
238 match the result we just got */
239 for (p
= dns_queue
; p
;) {
240 struct nmb_packet
*nmb
= &p
->packet
.nmb
;
241 struct nmb_name
*question
= &nmb
->question
.question_name
;
243 if (nmb_name_equal(question
, &r
.name
)) {
244 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
247 send_wins_name_query_response(NAM_ERR
, p
, NULL
);
249 send_wins_name_query_response(0,p
,namerec
);
254 p
->prev
->next
= p
->next
;
258 p
->next
->prev
= p
->prev
;
268 dns_current
= dns_queue
;
269 dns_queue
= dns_queue
->next
;
270 if (dns_queue
) dns_queue
->prev
= NULL
;
271 dns_current
->next
= NULL
;
273 if (!write_child(dns_current
)) {
274 DEBUG(3,("failed to send DNS query to child!\n"));
281 /***************************************************************************
283 ****************************************************************************/
284 BOOL
queue_dns_query(struct packet_struct
*p
,struct nmb_name
*question
,
285 struct name_record
**n
)
287 if (in_dns
|| fd_in
== -1)
291 if (!write_child(p
)) {
292 DEBUG(3,("failed to send DNS query to child!\n"));
306 DEBUG(3,("added DNS query for %s\n", nmb_namestr(question
)));
313 /***************************************************************************
314 we use this when we can't do async DNS lookups
315 ****************************************************************************/
316 BOOL
queue_dns_query(struct packet_struct
*p
,struct nmb_name
*question
,
317 struct name_record
**n
)
319 char *qname
= question
->name
;
320 struct in_addr dns_ip
;
322 DEBUG(3,("DNS search for %s - ", nmb_namestr(question
)));
324 /* Unblock TERM signal so we can be killed in DNS lookup. */
325 BlockSignals(False
, SIGTERM
);
327 dns_ip
.s_addr
= interpret_addr(qname
);
329 /* Re-block TERM signal. */
330 BlockSignals(True
, SIGTERM
);
332 *n
= add_dns_result(question
, dns_ip
);
334 send_wins_name_query_response(NAM_ERR
, p
, NULL
);
336 send_wins_name_query_response(0, p
, *n
);
340 /***************************************************************************
341 With sync dns there is no child to kill on SIGTERM.
342 ****************************************************************************/
343 void kill_async_dns_child(void)