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
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD$");
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
67static char *
68parse(struct hostent *hp)
69{
70	static char result[MAXHOSTNAMELEN * 2];
71	int i;
72	size_t len;
73	char addr[46];
74
75	if (hp == NULL)
76		return(NULL);
77
78	if (inet_ntop(hp->h_addrtype, hp->h_addr, addr, sizeof(addr)) == NULL)
79		return(NULL);
80
81	len = strlen(addr) + 1 + strlen(hp->h_name);
82	for (i = 0; hp->h_aliases[i]; i++)
83		len += strlen(hp->h_aliases[i]) + 1;
84	len++;
85
86	if (len > sizeof(result))
87		return(NULL);
88
89	bzero(result, sizeof(result));
90	snprintf(result, sizeof(result), "%s %s", addr, hp->h_name);
91	for (i = 0; hp->h_aliases[i]; i++) {
92		strcat(result, " ");
93		strcat(result, hp->h_aliases[i]);
94	}
95
96	return ((char *)&result);
97}
98
99#define MAXPACKET (64*1024)
100#define DEF_TTL 50
101
102#define BY_DNS_ID 1
103#define BY_RPC_XID 2
104
105extern struct hostent *__dns_getanswer(char *, int, char *, int);
106
107static TAILQ_HEAD(dns_qhead, circleq_dnsentry) qhead;
108
109struct circleq_dnsentry {
110	SVCXPRT *xprt;
111	unsigned long xid;
112	struct sockaddr_in client_addr;
113	unsigned long ypvers;
114	unsigned long id;
115	unsigned long ttl;
116	unsigned long type;
117	unsigned short prot_type;
118	char **domain;
119	char *name;
120	int addrtype;
121	int addrlen;
122	uint32_t addr[4];	/* IPv4 or IPv6 */
123	TAILQ_ENTRY(circleq_dnsentry) links;
124};
125
126static int pending = 0;
127
128int
129yp_init_resolver(void)
130{
131	TAILQ_INIT(&qhead);
132	if (!(_res.options & RES_INIT) && res_init() == -1) {
133		yp_error("res_init failed");
134		return(1);
135	}
136	if ((resfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
137		yp_error("couldn't create socket");
138		return(1);
139	}
140	if (fcntl(resfd, F_SETFL, O_NONBLOCK) == -1) {
141		yp_error("couldn't make resolver socket non-blocking");
142		return(1);
143	}
144	return(0);
145}
146
147static struct
148circleq_dnsentry *yp_malloc_dnsent(void)
149{
150	register struct circleq_dnsentry *q;
151
152	q = malloc(sizeof(struct circleq_dnsentry));
153
154	if (q == NULL) {
155		yp_error("failed to malloc() circleq dns entry");
156		return(NULL);
157	}
158
159	return(q);
160}
161
162/*
163 * Transmit a query.
164 */
165static unsigned long
166yp_send_dns_query(char *name, int type)
167{
168	char buf[MAXPACKET];
169	int n;
170	HEADER *hptr;
171	int ns;
172	int rval;
173	unsigned long id;
174
175	bzero(buf, sizeof(buf));
176
177	n = res_mkquery(QUERY,name,C_IN,type,NULL,0,NULL,buf,sizeof(buf));
178
179	if (n <= 0) {
180		yp_error("res_mkquery failed for %s type %d", name, type);
181		return(0);
182	}
183
184	hptr = (HEADER *)&buf;
185	id = ntohs(hptr->id);
186
187	for (ns = 0; ns < _res.nscount; ns++) {
188		rval = sendto(resfd, buf, n, 0,
189			(struct sockaddr *)&_res.nsaddr_list[ns],
190				sizeof(struct sockaddr));
191		if (rval == -1) {
192			yp_error("sendto failed");
193			return(0);
194		}
195	}
196
197	return(id);
198}
199
200static struct circleq_dnsentry *
201yp_find_dnsqent(unsigned long id, int type)
202{
203	register struct circleq_dnsentry *q;
204
205	TAILQ_FOREACH(q, &qhead, links) {
206		switch (type) {
207		case BY_RPC_XID:
208			if (id == q->xid)
209				return(q);
210			break;
211		case BY_DNS_ID:
212		default:
213			if (id == q->id)
214				return(q);
215			break;
216		}
217	}
218	return (NULL);
219}
220
221static void
222yp_send_dns_reply(struct circleq_dnsentry *q, char *buf)
223{
224	ypresponse result_v1;
225	ypresp_val result_v2;
226	unsigned long xid;
227	struct sockaddr_in client_addr;
228	xdrproc_t xdrfunc;
229	char *result;
230
231	/*
232	 * Set up correct reply struct and
233	 * XDR filter depending on ypvers.
234	 */
235	switch (q->ypvers) {
236	case YPVERS:
237		bzero((char *)&result_v2, sizeof(result_v2));
238
239		if (buf == NULL)
240			result_v2.stat = YP_NOKEY;
241		else {
242			result_v2.val.valdat_len = strlen(buf);
243			result_v2.val.valdat_val = buf;
244			result_v2.stat = YP_TRUE;
245		}
246		result = (char *)&result_v2;
247		xdrfunc = (xdrproc_t)xdr_ypresp_val;
248		break;
249	case YPOLDVERS:
250		/*
251		 * The odds are we will _never_ execute this
252		 * particular code, but we include it anyway
253		 * for the sake of completeness.
254		 */
255		bzero((char *)&result_v1, sizeof(result_v1));
256		result_v1.yp_resptype = YPRESP_VAL;
257
258#define YPVAL ypresponse_u.yp_resp_valtype
259		if (buf == NULL)
260			result_v1.YPVAL.stat = YP_NOKEY;
261		else {
262			result_v1.YPVAL.val.valdat_len = strlen(buf);
263			result_v1.YPVAL.val.valdat_val = buf;
264			result_v1.YPVAL.stat = YP_TRUE;
265		}
266		result = (char *)&result_v1;
267		xdrfunc = (xdrproc_t)xdr_ypresponse;
268		break;
269	default:
270		yp_error("bad YP program version (%lu)!", q->ypvers);
271			return;
272		break;
273	}
274
275	if (debug)
276		yp_error("sending dns reply to %s (%lu)",
277			inet_ntoa(q->client_addr.sin_addr), q->id);
278	/*
279	 * XXX This is disgusting. There's basically one transport
280	 * handle for UDP, but we're holding off on replying to a
281	 * client until we're ready, by which time we may have received
282	 * several other queries from other clients with different
283	 * transaction IDs. So to make the delayed response thing work,
284	 * we have to save the transaction ID and client address of
285	 * each request, then jam them into the transport handle when
286	 * we're ready to send a reply. Then after we've send the reply,
287	 * we put the old transaction ID and remote address back the
288	 * way we found 'em. This is _INCREDIBLY_ non-portable; it's
289	 * not even supported by the RPC library.
290	 */
291	/*
292	 * XXX Don't frob the transaction ID for TCP handles.
293	 */
294	if (q->prot_type == SOCK_DGRAM)
295		xid = svcudp_set_xid(q->xprt, q->xid);
296	client_addr = q->xprt->xp_raddr;
297	q->xprt->xp_raddr = q->client_addr;
298
299	if (!svc_sendreply(q->xprt, xdrfunc, result))
300		yp_error("svc_sendreply failed");
301
302	/*
303	 * Now that we sent the reply,
304	 * put the handle back the way it was.
305	 */
306	if (q->prot_type == SOCK_DGRAM)
307		svcudp_set_xid(q->xprt, xid);
308	q->xprt->xp_raddr = client_addr;
309
310	return;
311}
312
313/*
314 * Decrement TTL on all queue entries, possibly nuking
315 * any that have been around too long without being serviced.
316 */
317void
318yp_prune_dnsq(void)
319{
320	register struct circleq_dnsentry *q, *n;
321
322	q = TAILQ_FIRST(&qhead);
323	while (q != NULL) {
324		q->ttl--;
325		n = TAILQ_NEXT(q, links);
326		if (!q->ttl) {
327			TAILQ_REMOVE(&qhead, q, links);
328			free(q->name);
329			free(q);
330			pending--;
331		}
332		q = n;
333	}
334
335	if (pending < 0)
336		pending = 0;
337
338	return;
339}
340
341/*
342 * Data is pending on the DNS socket; check for valid replies
343 * to our queries and dispatch them to waiting clients.
344 */
345void
346yp_run_dnsq(void)
347{
348	register struct circleq_dnsentry *q;
349	char buf[sizeof(HEADER) + MAXPACKET];
350	struct sockaddr_in sin;
351	socklen_t len;
352	int rval;
353	HEADER *hptr;
354	struct hostent *hent;
355
356	if (debug)
357		yp_error("running dns queue");
358
359	bzero(buf, sizeof(buf));
360
361	len = sizeof(struct sockaddr_in);
362	rval = recvfrom(resfd, buf, sizeof(buf), 0,
363			(struct sockaddr *)&sin, &len);
364
365	if (rval == -1) {
366		yp_error("recvfrom failed: %s", strerror(errno));
367		return;
368	}
369
370	/*
371	 * We may have data left in the socket that represents
372	 * replies to earlier queries that we don't care about
373	 * anymore. If there are no lookups pending or the packet
374	 * ID doesn't match any of the queue IDs, just drop it
375	 * on the floor.
376	 */
377	hptr = (HEADER *)&buf;
378	if (!pending ||
379		(q = yp_find_dnsqent(ntohs(hptr->id), BY_DNS_ID)) == NULL) {
380		/* ignore */
381		return;
382	}
383
384	if (debug)
385		yp_error("got dns reply from %s", inet_ntoa(sin.sin_addr));
386
387	hent = __dns_getanswer(buf, rval, q->name, q->type);
388
389	if (hent != NULL) {
390		if (q->type == T_PTR) {
391			hent->h_addr = (char *)q->addr;
392			hent->h_addrtype = q->addrtype;
393			hent->h_length = q->addrlen;
394		}
395	}
396
397	/* Got an answer ready for a client -- send it off. */
398	yp_send_dns_reply(q, parse(hent));
399	pending--;
400	TAILQ_REMOVE(&qhead, q, links);
401	free(q->name);
402	free(q);
403
404	/* Decrement TTLs on other entries while we're here. */
405	yp_prune_dnsq();
406
407	return;
408}
409
410/*
411 * Queue and transmit an asynchronous DNS hostname lookup.
412 */
413ypstat
414yp_async_lookup_name(struct svc_req *rqstp, char *name, int af)
415{
416	register struct circleq_dnsentry *q;
417	socklen_t len;
418	int type;
419
420	/* Check for SOCK_DGRAM or SOCK_STREAM -- we need to know later */
421	type = -1;
422	len = sizeof(type);
423	if (getsockopt(rqstp->rq_xprt->xp_fd, SOL_SOCKET,
424					SO_TYPE, &type, &len) == -1) {
425		yp_error("getsockopt failed: %s", strerror(errno));
426		return(YP_YPERR);
427	}
428
429	/* Avoid transmitting dupe requests. */
430	if (type == SOCK_DGRAM &&
431	    yp_find_dnsqent(svcudp_get_xid(rqstp->rq_xprt),BY_RPC_XID) != NULL)
432		return(YP_TRUE);
433
434	if ((q = yp_malloc_dnsent()) == NULL)
435		return(YP_YPERR);
436
437	q->type = (af == AF_INET) ? T_A : T_AAAA;
438	q->ttl = DEF_TTL;
439	q->xprt = rqstp->rq_xprt;
440	q->ypvers = rqstp->rq_vers;
441	q->prot_type = type;
442	if (q->prot_type == SOCK_DGRAM)
443		q->xid = svcudp_get_xid(q->xprt);
444	q->client_addr = q->xprt->xp_raddr;
445	q->domain = _res.dnsrch;
446	q->id = yp_send_dns_query(name, q->type);
447
448	if (q->id == 0) {
449		yp_error("DNS query failed");
450		free(q);
451		return(YP_YPERR);
452	}
453
454	q->name = strdup(name);
455	TAILQ_INSERT_HEAD(&qhead, q, links);
456	pending++;
457
458	if (debug)
459		yp_error("queueing async DNS name lookup (%lu)", q->id);
460
461	yp_prune_dnsq();
462	return(YP_TRUE);
463}
464
465/*
466 * Queue and transmit an asynchronous DNS IP address lookup.
467 */
468ypstat
469yp_async_lookup_addr(struct svc_req *rqstp, char *addr, int af)
470{
471	register struct circleq_dnsentry *q;
472	char buf[MAXHOSTNAMELEN], *qp;
473	uint32_t abuf[4];	/* IPv4 or IPv6 */
474	u_char *uaddr = (u_char *)abuf;
475	socklen_t len;
476	int type, n;
477
478	/* Check for SOCK_DGRAM or SOCK_STREAM -- we need to know later */
479	type = -1;
480	len = sizeof(type);
481	if (getsockopt(rqstp->rq_xprt->xp_fd, SOL_SOCKET,
482					SO_TYPE, &type, &len) == -1) {
483		yp_error("getsockopt failed: %s", strerror(errno));
484		return(YP_YPERR);
485	}
486
487	/* Avoid transmitting dupe requests. */
488	if (type == SOCK_DGRAM &&
489	    yp_find_dnsqent(svcudp_get_xid(rqstp->rq_xprt),BY_RPC_XID) != NULL)
490		return(YP_TRUE);
491
492	switch (af) {
493	case AF_INET:
494		if (inet_aton(addr, (struct in_addr *)uaddr) != 1)
495			return(YP_NOKEY);
496		snprintf(buf, sizeof(buf), "%u.%u.%u.%u.in-addr.arpa",
497		    (uaddr[3] & 0xff), (uaddr[2] & 0xff),
498		    (uaddr[1] & 0xff), (uaddr[0] & 0xff));
499		len = INADDRSZ;
500		break;
501	case AF_INET6:
502		if (inet_pton(af, addr, uaddr) != 1)
503			return(YP_NOKEY);
504		qp = buf;
505		for (n = IN6ADDRSZ - 1; n >= 0; n--) {
506			qp += (size_t)sprintf(qp, "%x.%x.", uaddr[n] & 0xf,
507			    (uaddr[n] >> 4) & 0xf);
508		}
509		strlcat(buf, "ip6.arpa", sizeof(buf));
510		len = IN6ADDRSZ;
511		break;
512	default:
513		return(YP_YPERR);
514	}
515
516	if ((q = yp_malloc_dnsent()) == NULL)
517		return(YP_YPERR);
518
519	if (debug)
520		yp_error("DNS address is: %s", buf);
521
522	q->type = T_PTR;
523	q->ttl = DEF_TTL;
524	q->xprt = rqstp->rq_xprt;
525	q->ypvers = rqstp->rq_vers;
526	q->domain = NULL;
527	q->prot_type = type;
528	if (q->prot_type == SOCK_DGRAM)
529		q->xid = svcudp_get_xid(q->xprt);
530	q->client_addr = q->xprt->xp_raddr;
531	q->id = yp_send_dns_query(buf, q->type);
532
533	if (q->id == 0) {
534		yp_error("DNS query failed");
535		free(q);
536		return(YP_YPERR);
537	}
538
539	memcpy(q->addr, uaddr, len);
540	q->addrlen = len;
541	q->addrtype = af;
542	q->name = strdup(buf);
543	TAILQ_INSERT_HEAD(&qhead, q, links);
544	pending++;
545
546	if (debug)
547		yp_error("queueing async DNS address lookup (%lu)", q->id);
548
549	yp_prune_dnsq();
550	return(YP_TRUE);
551}
552