Style(9) cleanup.
[dragonfly.git] / usr.sbin / ypserv / yp_dnslookup.c
1 /*
2  * Copyright (c) 1995, 1996
3  *      Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Bill Paul.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $FreeBSD: src/usr.sbin/ypserv/yp_dnslookup.c,v 1.16.2.1 2002/02/15 00:47:00 des Exp $
33  * $DragonFly: src/usr.sbin/ypserv/yp_dnslookup.c,v 1.3 2004/03/31 23:20:22 cpressey Exp $
34  */
35
36 /*
37  * Do standard and reverse DNS lookups using the resolver library.
38  * Take care of all the dirty work here so the main program only has to
39  * pass us a pointer to an array of characters.
40  *
41  * We have to use direct resolver calls here otherwise the YP server
42  * could end up looping by calling itself over and over again until
43  * it disappeared up its own belly button.
44  */
45
46 #include <sys/param.h>
47 #include <sys/socket.h>
48 #include <sys/time.h>
49 #include <sys/fcntl.h>
50 #include <sys/queue.h>
51 #include <netinet/in.h>
52 #include <arpa/inet.h>
53 #include <arpa/nameser.h>
54
55 #include <ctype.h>
56 #include <errno.h>
57 #include <netdb.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <resolv.h>
62 #include <unistd.h>
63
64 #include <rpcsvc/yp.h>
65 #include "yp_extern.h"
66
67 static char *
68 parse(struct hostent *hp)
69 {
70         static char result[MAXHOSTNAMELEN * 2];
71         int len,i;
72         struct in_addr addr;
73
74         if (hp == NULL)
75                 return(NULL);
76
77         len = 16 + strlen(hp->h_name);
78         for (i = 0; hp->h_aliases[i]; i++)
79                 len += strlen(hp->h_aliases[i]) + 1;
80         len++;
81
82         if (len > sizeof(result))
83                 return(NULL);
84
85         bzero(result, sizeof(result));
86
87         bcopy(hp->h_addr, &addr, sizeof(struct in_addr));
88         snprintf(result, sizeof(result), "%s %s", inet_ntoa(addr), hp->h_name);
89
90         for (i = 0; hp->h_aliases[i]; i++) {
91                 strcat(result, " ");
92                 strcat(result, hp->h_aliases[i]);
93         }
94
95         return ((char *)&result);
96 }
97
98 #define MAXPACKET 1024
99 #define DEF_TTL 50
100
101 #define BY_DNS_ID 1
102 #define BY_RPC_XID 2
103
104 extern struct hostent *__dns_getanswer(char *, int, char *, int);
105
106 static CIRCLEQ_HEAD(dns_qhead, circleq_dnsentry) qhead;
107
108 struct circleq_dnsentry {
109         SVCXPRT *xprt;
110         unsigned long xid;
111         struct sockaddr_in client_addr;
112         unsigned long ypvers;
113         unsigned long id;
114         unsigned long ttl;
115         unsigned long type;
116         unsigned short prot_type;
117         char **domain;
118         char *name;
119         struct in_addr addr;
120         CIRCLEQ_ENTRY(circleq_dnsentry) links;
121 };
122
123 static int pending = 0;
124
125 int
126 yp_init_resolver(void)
127 {
128         CIRCLEQ_INIT(&qhead);
129         if (!(_res.options & RES_INIT) && res_init() == -1) {
130                 yp_error("res_init failed");
131                 return(1);
132         }
133         if ((resfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
134                 yp_error("couldn't create socket");
135                 return(1);
136         }
137         if (fcntl(resfd, F_SETFL, O_NONBLOCK) == -1) {
138                 yp_error("couldn't make resolver socket non-blocking");
139                 return(1);
140         }
141         return(0);
142 }
143
144 static struct circleq_dnsentry *
145 yp_malloc_dnsent(void)
146 {
147         struct circleq_dnsentry *q;
148
149         q = (struct circleq_dnsentry *)malloc(sizeof(struct circleq_dnsentry));
150
151         if (q == NULL) {
152                 yp_error("failed to malloc() circleq dns entry");
153                 return(NULL);
154         }
155
156         return(q);
157 }
158
159 /*
160  * Transmit a query.
161  */
162 static unsigned long
163 yp_send_dns_query(char *name, int type)
164 {
165         char buf[MAXPACKET];
166         int n;
167         HEADER *hptr;
168         int ns;
169         int rval;
170         unsigned long id;
171
172         bzero(buf, sizeof(buf));
173
174         n = res_mkquery(QUERY,name,C_IN,type,NULL,0,NULL,buf,sizeof(buf));
175
176         if (n <= 0) {
177                 yp_error("res_mkquery failed");
178                 return(0);
179         }
180
181         hptr = (HEADER *)&buf;
182         id = ntohs(hptr->id);
183
184         for (ns = 0; ns < _res.nscount; ns++) {
185                 rval = sendto(resfd, buf, n, 0,
186                         (struct sockaddr *)&_res.nsaddr_list[ns],
187                                 sizeof(struct sockaddr));
188                 if (rval == -1) {
189                         yp_error("sendto failed");
190                         return(0);
191                 }
192         }
193
194         return(id);
195 }
196
197 static struct circleq_dnsentry *
198 yp_find_dnsqent(unsigned long id, int type)
199 {
200         struct circleq_dnsentry *q;
201
202         for (q = qhead.cqh_first; q != (void *)&qhead; q = q->links.cqe_next) {
203                 switch (type) {
204                 case BY_RPC_XID:
205                         if (id == q->xid)
206                                 return(q);
207                         break;
208                 case BY_DNS_ID:
209                 default:
210                         if (id == q->id)
211                                 return(q);
212                         break;
213                 }
214         }
215         return (NULL);
216 }
217
218 static void
219 yp_send_dns_reply(struct circleq_dnsentry *q, char *buf)
220 {
221         ypresponse result_v1;
222         ypresp_val result_v2;
223         unsigned long xid;
224         struct sockaddr_in client_addr;
225         xdrproc_t xdrfunc;
226         char *result;
227
228         /*
229          * Set up correct reply struct and
230          * XDR filter depending on ypvers.
231          */
232         switch (q->ypvers) {
233         case YPVERS:
234                 bzero((char *)&result_v2, sizeof(result_v2));
235
236                 if (buf == NULL)
237                         result_v2.stat = YP_NOKEY;
238                 else {
239                         result_v2.val.valdat_len = strlen(buf);
240                         result_v2.val.valdat_val = buf;
241                         result_v2.stat = YP_TRUE;
242                 }
243                 result = (char *)&result_v2;
244                 xdrfunc = (xdrproc_t)xdr_ypresp_val;
245                 break;
246         case YPOLDVERS:
247                 /*
248                  * The odds are we will _never_ execute this
249                  * particular code, but we include it anyway
250                  * for the sake of completeness.
251                  */
252                 bzero((char *)&result_v1, sizeof(result_v1));
253                 result_v1.yp_resptype = YPRESP_VAL;
254 #               define YPVAL ypresponse_u.yp_resp_valtype
255
256                 if (buf == NULL)
257                         result_v1.YPVAL.stat = YP_NOKEY;
258                 else {
259                         result_v1.YPVAL.val.valdat_len = strlen(buf);
260                         result_v1.YPVAL.val.valdat_val = buf;
261                         result_v1.YPVAL.stat = YP_TRUE;
262                 }
263                 result = (char *)&result_v1;
264                 xdrfunc = (xdrproc_t)xdr_ypresponse;
265                 break;
266         default:
267                 yp_error("bad YP program version (%lu)!", q->ypvers);
268                         return;
269                 break;
270         }
271
272         if (debug)
273                 yp_error("sending dns reply to %s (%lu)",
274                         inet_ntoa(q->client_addr.sin_addr), q->id);
275         /*
276          * XXX This is disgusting. There's basically one transport
277          * handle for UDP, but we're holding off on replying to a
278          * client until we're ready, by which time we may have received
279          * several other queries from other clients with different
280          * transaction IDs. So to make the delayed response thing work,
281          * we have to save the transaction ID and client address of
282          * each request, then jam them into the transport handle when
283          * we're ready to send a reply. Then after we've send the reply,
284          * we put the old transaction ID and remote address back the
285          * way we found 'em. This is _INCREDIBLY_ non-portable; it's
286          * not even supported by the RPC library.
287          */
288         /*
289          * XXX Don't frob the transaction ID for TCP handles.
290          */
291         if (q->prot_type == SOCK_DGRAM)
292                 xid = svcudp_set_xid(q->xprt, q->xid);
293         client_addr = q->xprt->xp_raddr;
294         q->xprt->xp_raddr = q->client_addr;
295
296         if (!svc_sendreply(q->xprt, xdrfunc, result))
297                 yp_error("svc_sendreply failed");
298
299         /*
300          * Now that we sent the reply,
301          * put the handle back the way it was.
302          */
303         if (q->prot_type == SOCK_DGRAM)
304                 svcudp_set_xid(q->xprt, xid);
305         q->xprt->xp_raddr = client_addr;
306
307         return;
308 }
309
310 /*
311  * Decrement TTL on all queue entries, possibly nuking
312  * any that have been around too long without being serviced.
313  */
314 void
315 yp_prune_dnsq(void)
316 {
317         struct circleq_dnsentry *q, *n;
318
319         q = qhead.cqh_first;
320         while (q != (void *)&qhead) {
321                 q->ttl--;
322                 n = q->links.cqe_next;
323                 if (!q->ttl) {
324                         CIRCLEQ_REMOVE(&qhead, q, links);
325                         free(q->name);
326                         free(q);
327                         pending--;
328                 }
329                 q = n;
330         }
331
332         if (pending < 0)
333                 pending = 0;
334
335         return;
336 }
337
338 /*
339  * Data is pending on the DNS socket; check for valid replies
340  * to our queries and dispatch them to waiting clients.
341  */
342 void
343 yp_run_dnsq(void)
344 {
345         struct circleq_dnsentry *q;
346         char buf[sizeof(HEADER) + MAXPACKET];
347         char retrybuf[MAXHOSTNAMELEN];
348         struct sockaddr_in sin;
349         int rval;
350         int len;
351         HEADER *hptr;
352         struct hostent *hent;
353
354         if (debug)
355                 yp_error("running dns queue");
356
357         bzero(buf, sizeof(buf));
358
359         len = sizeof(struct sockaddr_in);
360         rval = recvfrom(resfd, buf, sizeof(buf), 0,
361                         (struct sockaddr *)&sin, &len);
362
363         if (rval == -1) {
364                 yp_error("recvfrom failed: %s", strerror(errno));
365                 return;
366         }
367
368         /*
369          * We may have data left in the socket that represents
370          * replies to earlier queries that we don't care about
371          * anymore. If there are no lookups pending or the packet
372          * ID doesn't match any of the queue IDs, just drop it
373          * on the floor.
374          */
375         hptr = (HEADER *)&buf;
376         if (!pending ||
377                 (q = yp_find_dnsqent(ntohs(hptr->id), BY_DNS_ID)) == NULL) {
378                 /* ignore */
379                 return;
380         }
381
382         if (debug)
383                 yp_error("got dns reply from %s", inet_ntoa(sin.sin_addr));
384
385         hent = __dns_getanswer(buf, rval, q->name, q->type);
386
387         /*
388          * If the lookup failed, try appending one of the domains
389          * from resolv.conf. If we have no domains to test, the
390          * query has failed.
391          */
392         if (hent == NULL) {
393                 if ((h_errno == TRY_AGAIN || h_errno == NO_RECOVERY)
394                                         && q->domain && *q->domain) {
395                         snprintf(retrybuf, sizeof(retrybuf), "%s.%s",
396                                                 q->name, *q->domain);
397                         if (debug)
398                                 yp_error("retrying with: %s", retrybuf);
399                         q->id = yp_send_dns_query(retrybuf, q->type);
400                         q->ttl = DEF_TTL;
401                         q->domain++;
402                         return;
403                 }
404         } else {
405                 if (q->type == T_PTR) {
406                         hent->h_addr = (char *)&q->addr.s_addr;
407                         hent->h_length = sizeof(struct in_addr);
408                 }
409         }
410
411         /* Got an answer ready for a client -- send it off. */
412         yp_send_dns_reply(q, parse(hent));
413         pending--;
414         CIRCLEQ_REMOVE(&qhead, q, links);
415         free(q->name);
416         free(q);
417
418         /* Decrement TTLs on other entries while we're here. */
419         yp_prune_dnsq();
420
421         return;
422 }
423
424 /*
425  * Queue and transmit an asynchronous DNS hostname lookup.
426  */
427 ypstat
428 yp_async_lookup_name(struct svc_req *rqstp, char *name)
429 {
430         struct circleq_dnsentry *q;
431         int type, len;
432
433         /* Check for SOCK_DGRAM or SOCK_STREAM -- we need to know later */
434         type = -1; len = sizeof(type);
435         if (getsockopt(rqstp->rq_xprt->xp_sock, SOL_SOCKET,
436                                         SO_TYPE, &type, &len) == -1) {
437                 yp_error("getsockopt failed: %s", strerror(errno));
438                 return(YP_YPERR);
439         }
440
441         /* Avoid transmitting dupe requests. */
442         if (type == SOCK_DGRAM &&
443             yp_find_dnsqent(svcudp_get_xid(rqstp->rq_xprt),BY_RPC_XID) != NULL)
444                 return(YP_TRUE);
445
446         if ((q = yp_malloc_dnsent()) == NULL)
447                 return(YP_YPERR);
448
449         q->type = T_A;
450         q->ttl = DEF_TTL;
451         q->xprt = rqstp->rq_xprt;
452         q->ypvers = rqstp->rq_vers;
453         q->prot_type = type;
454         if (q->prot_type == SOCK_DGRAM)
455                 q->xid = svcudp_get_xid(q->xprt);
456         q->client_addr = q->xprt->xp_raddr;
457         q->domain = _res.dnsrch;
458         q->id = yp_send_dns_query(name, q->type);
459
460         if (q->id == 0) {
461                 yp_error("DNS query failed");
462                 free(q);
463                 return(YP_YPERR);
464         }
465
466         q->name = strdup(name);
467         CIRCLEQ_INSERT_HEAD(&qhead, q, links);
468         pending++;
469
470         if (debug)
471                 yp_error("queueing async DNS name lookup (%d)", q->id);
472
473         yp_prune_dnsq();
474         return(YP_TRUE);
475 }
476
477 /*
478  * Queue and transmit an asynchronous DNS IP address lookup.
479  */
480 ypstat yp_async_lookup_addr(struct svc_req *rqstp, char *addr)
481 {
482         struct circleq_dnsentry *q;
483         char buf[MAXHOSTNAMELEN];
484         int a, b, c, d;
485         int type, len;
486
487         /* Check for SOCK_DGRAM or SOCK_STREAM -- we need to know later */
488         type = -1; len = sizeof(type);
489         if (getsockopt(rqstp->rq_xprt->xp_sock, SOL_SOCKET,
490                                         SO_TYPE, &type, &len) == -1) {
491                 yp_error("getsockopt failed: %s", strerror(errno));
492                 return(YP_YPERR);
493         }
494
495         /* Avoid transmitting dupe requests. */
496         if (type == SOCK_DGRAM &&
497             yp_find_dnsqent(svcudp_get_xid(rqstp->rq_xprt),BY_RPC_XID) != NULL)
498                 return(YP_TRUE);
499
500         if ((q = yp_malloc_dnsent()) == NULL)
501                 return(YP_YPERR);
502
503         if (sscanf(addr, "%d.%d.%d.%d", &a, &b, &c, &d) != 4)
504                 return(YP_NOKEY);
505
506         snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa", d, c, b, a);
507
508         if (debug)
509                 yp_error("DNS address is: %s", buf);
510
511         q->type = T_PTR;
512         q->ttl = DEF_TTL;
513         q->xprt = rqstp->rq_xprt;
514         q->ypvers = rqstp->rq_vers;
515         q->domain = NULL;
516         q->prot_type = type;
517         if (q->prot_type == SOCK_DGRAM)
518                 q->xid = svcudp_get_xid(q->xprt);
519         q->client_addr = q->xprt->xp_raddr;
520         q->id = yp_send_dns_query(buf, q->type);
521
522         if (q->id == 0) {
523                 yp_error("DNS query failed");
524                 free(q);
525                 return(YP_YPERR);
526         }
527
528         inet_aton(addr, &q->addr);
529         q->name = strdup(buf);
530         CIRCLEQ_INSERT_HEAD(&qhead, q, links);
531         pending++;
532
533         if (debug)
534                 yp_error("queueing async DNS address lookup (%d)", q->id);
535
536         yp_prune_dnsq();
537         return(YP_TRUE);
538 }