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 extern int DEBUGLEVEL;
25 /***************************************************************************
26 Add a DNS result to the name cache.
27 ****************************************************************************/
29 static struct name_record *add_dns_result(struct nmb_name *question, struct in_addr addr)
31 int name_type = question->name_type;
32 char *qname = question->name;
36 /* add the fail to WINS cache of names. give it 1 hour in the cache */
37 DEBUG(3,("add_dns_result: Negative DNS answer for %s\n", qname));
38 add_name_to_subnet(wins_server_subnet,qname,name_type,
39 NB_ACTIVE, 60*60, DNSFAIL_NAME, 1, &addr);
43 /* add it to our WINS cache of names. give it 2 hours in the cache */
44 DEBUG(3,("add_dns_result: DNS gave answer for %s of %s\n", qname, inet_ntoa(addr)));
46 return add_name_to_subnet(wins_server_subnet,qname,name_type,
47 NB_ACTIVE, 2*60*60, DNS_NAME, 1, &addr);
54 static int fd_in = -1, fd_out = -1;
55 static int child_pid = -1;
58 /* this is the structure that is passed between the parent and child */
61 struct in_addr result;
64 /* a queue of pending requests waiting to be sent to the DNS child */
65 static struct packet_struct *dns_queue;
67 /* the packet currently being processed by the dns child */
68 static struct packet_struct *dns_current;
71 /***************************************************************************
72 return the fd used to gather async dns replies. This is added to the select
74 ****************************************************************************/
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 fstrcpy(qname, r.name.name);
96 r.result.s_addr = interpret_addr(qname);
98 if (write_data(fd_out, (char *)&r, sizeof(r)) != sizeof(r))
105 /**************************************************************************** **
106 catch a sigterm (in the child process - the parent has a different handler
107 see nmbd.c for details).
108 We need a separate term handler here so we don't release any
109 names that our parent is going to release, or overwrite a
110 WINS db that our parent is going to write.
111 **************************************************************************** */
113 static int sig_term(void)
116 /* Keep compiler happy.. */
120 /***************************************************************************
121 Called by the parent process when it receives a SIGTERM - also kills the
122 child so we don't get child async dns processes lying around, causing trouble.
123 ****************************************************************************/
125 void kill_async_dns_child(void)
127 if(child_pid != 0 && child_pid != -1)
128 kill(child_pid, SIGTERM);
131 /***************************************************************************
132 create a child process to handle DNS lookups
133 ****************************************************************************/
134 void start_async_dns(void)
138 signal(SIGCLD, SIG_IGN);
140 if (pipe(fd1) || pipe(fd2)) {
157 signal(SIGUSR2, SIG_IGN);
158 signal(SIGUSR1, SIG_IGN);
159 signal(SIGHUP, SIG_IGN);
160 signal(SIGTERM, SIGNAL_CAST sig_term );
166 /***************************************************************************
167 check if a particular name is already being queried
168 ****************************************************************************/
169 static BOOL query_current(struct query_record *r)
171 return dns_current &&
172 nmb_name_equal(&r->name,
173 &dns_current->packet.nmb.question.question_name);
177 /***************************************************************************
178 write a query to the child process
179 ****************************************************************************/
180 static BOOL write_child(struct packet_struct *p)
182 struct query_record r;
184 r.name = p->packet.nmb.question.question_name;
186 return write_data(fd_out, (char *)&r, sizeof(r)) == sizeof(r);
189 /***************************************************************************
191 ****************************************************************************/
192 void run_dns_queue(void)
194 struct query_record r;
195 struct packet_struct *p, *p2;
196 struct name_record *namerec;
202 /* Allow SIGTERM to kill us. */
203 BlockSignals(False, SIGTERM);
205 if (!process_exists(child_pid)) {
210 if ((size=read_data(fd_in, (char *)&r, sizeof(r))) != sizeof(r)) {
212 DEBUG(0,("Incomplete DNS answer from child!\n"));
215 BlockSignals(True, SIGTERM);
219 BlockSignals(True, SIGTERM);
221 namerec = add_dns_result(&r.name, r.result);
224 if (query_current(&r)) {
225 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
228 send_wins_name_query_response(NAM_ERR, dns_current, NULL);
230 send_wins_name_query_response(0,dns_current,namerec);
234 dns_current->locked = False;
235 free_packet(dns_current);
239 /* loop over the whole dns queue looking for entries that
240 match the result we just got */
241 for (p = dns_queue; p;) {
242 struct nmb_packet *nmb = &p->packet.nmb;
243 struct nmb_name *question = &nmb->question.question_name;
245 if (nmb_name_equal(question, &r.name)) {
246 DEBUG(3,("DNS calling send_wins_name_query_response\n"));
249 send_wins_name_query_response(NAM_ERR, p, NULL);
251 send_wins_name_query_response(0,p,namerec);
256 p->prev->next = p->next;
260 p->next->prev = p->prev;
270 dns_current = dns_queue;
271 dns_queue = dns_queue->next;
272 if (dns_queue) dns_queue->prev = NULL;
273 dns_current->next = NULL;
275 if (!write_child(dns_current)) {
276 DEBUG(3,("failed to send DNS query to child!\n"));
283 /***************************************************************************
285 ****************************************************************************/
286 BOOL queue_dns_query(struct packet_struct *p,struct nmb_name *question,
287 struct name_record **n)
289 if (in_dns || fd_in == -1)
293 if (!write_child(p)) {
294 DEBUG(3,("failed to send DNS query to child!\n"));
308 DEBUG(3,("added DNS query for %s\n", namestr(question)));
315 /***************************************************************************
316 we use this then we can't do async DNS lookups
317 ****************************************************************************/
318 BOOL queue_dns_query(struct packet_struct *p,struct nmb_name *question,
319 struct name_record **n)
321 char *qname = question->name;
322 struct in_addr dns_ip;
324 DEBUG(3,("DNS search for %s - ", namestr(question)));
326 /* Unblock TERM signal so we can be killed in DNS lookup. */
327 BlockSignals(False, SIGTERM);
329 dns_ip.s_addr = interpret_addr(qname);
331 /* Re-block TERM signal. */
332 BlockSignals(True, SIGTERM);
334 *n = add_dns_result(question, dns_ip);
336 send_wins_name_query_response(NAM_ERR, p, NULL);
338 send_wins_name_query_response(0, p, *n);
342 /***************************************************************************
343 With sync dns there is no child to kill on SIGTERM.
344 ****************************************************************************/
345 void kill_async_dns_child(void)