xref: /titanic_51/usr/src/lib/libadutils/common/srv_query.c (revision dc32d872cbeb56532bcea030255db9cd79bac7da) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
25  */
26 
27 /*
28  * DNS query helper functions for addisc.c
29  */
30 
31 #include <stdio.h>
32 #include <string.h>
33 #include <strings.h>
34 #include <unistd.h>
35 #include <assert.h>
36 #include <stdlib.h>
37 #include <net/if.h>
38 #include <sys/types.h>
39 #include <sys/socket.h>
40 #include <sys/sockio.h>
41 #include <netinet/in.h>
42 #include <arpa/inet.h>
43 #include <arpa/nameser.h>
44 #include <resolv.h>
45 #include <netdb.h>
46 #include <ctype.h>
47 #include <errno.h>
48 #include <ldap.h>
49 #include <sasl/sasl.h>
50 #include <sys/u8_textprep.h>
51 #include <syslog.h>
52 #include <uuid/uuid.h>
53 #include <ads/dsgetdc.h>
54 #include "adutils_impl.h"
55 #include "addisc_impl.h"
56 
57 static void save_addr(ad_disc_cds_t *, sa_family_t, uchar_t *, size_t);
58 static struct addrinfo *make_addrinfo(sa_family_t, uchar_t *, size_t);
59 
60 static void do_getaddrinfo(ad_disc_cds_t *);
61 static ad_disc_cds_t *srv_parse(uchar_t *, int, int *, int *);
62 static void add_preferred(ad_disc_cds_t *, ad_disc_ds_t *, int *, int);
63 static void get_addresses(ad_disc_cds_t *, int);
64 
65 /*
66  * Simplified version of srv_query() for domain auto-discovery.
67  */
68 int
69 srv_getdom(res_state state, const char *svc_name, char **rrname)
70 {
71 	union {
72 		HEADER hdr;
73 		uchar_t buf[NS_MAXMSG];
74 	} msg;
75 	int len, qdcount, ancount;
76 	uchar_t *ptr, *eom;
77 	char namebuf[NS_MAXDNAME];
78 
79 	/* query necessary resource records */
80 
81 	*rrname = NULL;
82 	if (DBG(DNS, 1))  {
83 		logger(LOG_DEBUG, "Looking for SRV RRs '%s.*'", svc_name);
84 	}
85 	len = res_nsearch(state, svc_name, C_IN, T_SRV,
86 	    msg.buf, sizeof (msg.buf));
87 	if (len < 0) {
88 		if (DBG(DNS, 0)) {
89 			logger(LOG_DEBUG,
90 			    "DNS search for '%s' failed (%s)",
91 			    svc_name, hstrerror(state->res_h_errno));
92 		}
93 		return (-1);
94 	}
95 
96 	if (len > sizeof (msg.buf)) {
97 		logger(LOG_WARNING,
98 		    "DNS query %ib message doesn't fit into %ib buffer",
99 		    len, sizeof (msg.buf));
100 		len = sizeof (msg.buf);
101 	}
102 
103 	/* parse the reply header */
104 
105 	ptr = msg.buf + sizeof (msg.hdr);
106 	eom = msg.buf + len;
107 	qdcount = ntohs(msg.hdr.qdcount);
108 	ancount = ntohs(msg.hdr.ancount);
109 
110 	/* skip the question section */
111 
112 	len = ns_skiprr(ptr, eom, ns_s_qd, qdcount);
113 	if (len < 0) {
114 		logger(LOG_ERR, "DNS query invalid message format");
115 		return (-1);
116 	}
117 	ptr += len;
118 
119 	/* parse the answer section */
120 	if (ancount < 1) {
121 		logger(LOG_ERR, "DNS query - no answers");
122 		return (-1);
123 	}
124 
125 	len = dn_expand(msg.buf, eom, ptr, namebuf, sizeof (namebuf));
126 	if (len < 0) {
127 		logger(LOG_ERR, "DNS query invalid message format");
128 		return (-1);
129 	}
130 	*rrname = strdup(namebuf);
131 	if (*rrname == NULL) {
132 		logger(LOG_ERR, "Out of memory");
133 		return (-1);
134 	}
135 
136 	return (0);
137 }
138 
139 
140 /*
141  * Compare SRC RRs; used with qsort().  Sort order:
142  * "Earliest" (lowest number) priority first,
143  * then weight highest to lowest.
144  */
145 static int
146 srvcmp(ad_disc_ds_t *s1, ad_disc_ds_t *s2)
147 {
148 	if (s1->priority < s2->priority)
149 		return (-1);
150 	else if (s1->priority > s2->priority)
151 		return (1);
152 
153 	if (s1->weight < s2->weight)
154 		return (1);
155 	else if (s1->weight > s2->weight)
156 		return (-1);
157 
158 	return (0);
159 }
160 
161 /*
162  * Query or search the SRV RRs for a given name.
163  *
164  * If dname == NULL then search (as in res_nsearch(3RESOLV), honoring any
165  * search list/option), else query (as in res_nquery(3RESOLV)).
166  *
167  * The output TTL will be the one of the SRV RR with the lowest TTL.
168  */
169 ad_disc_cds_t *
170 srv_query(res_state state, const char *svc_name, const char *dname,
171     ad_disc_ds_t *prefer)
172 {
173 	ad_disc_cds_t *cds_res = NULL;
174 	uchar_t *msg = NULL;
175 	int len, scnt, maxcnt;
176 
177 	msg = malloc(NS_MAXMSG);
178 	if (msg == NULL) {
179 		logger(LOG_ERR, "Out of memory");
180 		return (NULL);
181 	}
182 
183 	/* query necessary resource records */
184 
185 	/* Search, querydomain or query */
186 	if (dname == NULL) {
187 		dname = "*";
188 		if (DBG(DNS, 1))  {
189 			logger(LOG_DEBUG, "Looking for SRV RRs '%s.*'",
190 			    svc_name);
191 		}
192 		len = res_nsearch(state, svc_name, C_IN, T_SRV,
193 		    msg, NS_MAXMSG);
194 		if (len < 0) {
195 			if (DBG(DNS, 0)) {
196 				logger(LOG_DEBUG,
197 				    "DNS search for '%s' failed (%s)",
198 				    svc_name, hstrerror(state->res_h_errno));
199 			}
200 			goto errout;
201 		}
202 	} else { /* dname != NULL */
203 		if (DBG(DNS, 1)) {
204 			logger(LOG_DEBUG, "Looking for SRV RRs '%s.%s' ",
205 			    svc_name, dname);
206 		}
207 
208 		len = res_nquerydomain(state, svc_name, dname, C_IN, T_SRV,
209 		    msg, NS_MAXMSG);
210 
211 		if (len < 0) {
212 			if (DBG(DNS, 0)) {
213 				logger(LOG_DEBUG, "DNS: %s.%s: %s",
214 				    svc_name, dname,
215 				    hstrerror(state->res_h_errno));
216 			}
217 			goto errout;
218 		}
219 	}
220 
221 	if (len > NS_MAXMSG) {
222 		logger(LOG_WARNING,
223 		    "DNS query %ib message doesn't fit into %ib buffer",
224 		    len, NS_MAXMSG);
225 		len = NS_MAXMSG;
226 	}
227 
228 
229 	/* parse the reply header */
230 
231 	cds_res = srv_parse(msg, len, &scnt, &maxcnt);
232 	if (cds_res == NULL)
233 		goto errout;
234 
235 	if (prefer != NULL)
236 		add_preferred(cds_res, prefer, &scnt, maxcnt);
237 
238 	get_addresses(cds_res, scnt);
239 
240 	/* sort list of candidates */
241 	if (scnt > 1)
242 		qsort(cds_res, scnt, sizeof (*cds_res),
243 		    (int (*)(const void *, const void *))srvcmp);
244 
245 	free(msg);
246 	return (cds_res);
247 
248 errout:
249 	free(msg);
250 	return (NULL);
251 }
252 
253 static ad_disc_cds_t *
254 srv_parse(uchar_t *msg, int len, int *scnt, int *maxcnt)
255 {
256 	ad_disc_cds_t *cds;
257 	ad_disc_cds_t *cds_res = NULL;
258 	HEADER *hdr;
259 	int i, qdcount, ancount, nscount, arcount;
260 	uchar_t *ptr, *eom;
261 	uchar_t *end;
262 	uint16_t type;
263 	/* LINTED  E_FUNC_SET_NOT_USED */
264 	uint16_t class;
265 	uint32_t rttl;
266 	uint16_t size;
267 	char namebuf[NS_MAXDNAME];
268 
269 	eom = msg + len;
270 	hdr = (void *)msg;
271 	ptr = msg + sizeof (HEADER);
272 
273 	qdcount = ntohs(hdr->qdcount);
274 	ancount = ntohs(hdr->ancount);
275 	nscount = ntohs(hdr->nscount);
276 	arcount = ntohs(hdr->arcount);
277 
278 	/* skip the question section */
279 
280 	len = ns_skiprr(ptr, eom, ns_s_qd, qdcount);
281 	if (len < 0) {
282 		logger(LOG_ERR, "DNS query invalid message format");
283 		return (NULL);
284 	}
285 	ptr += len;
286 
287 	/*
288 	 * Walk through the answer section, building the result array.
289 	 * The array size is +2 because we (possibly) add the preferred
290 	 * DC if it was not there, and an empty one (null termination).
291 	 */
292 
293 	*maxcnt = ancount + 2;
294 	cds_res = calloc(*maxcnt, sizeof (*cds_res));
295 	if (cds_res == NULL) {
296 		logger(LOG_ERR, "Out of memory");
297 		return (NULL);
298 	}
299 
300 	cds = cds_res;
301 	for (i = 0; i < ancount; i++) {
302 
303 		len = dn_expand(msg, eom, ptr, namebuf,
304 		    sizeof (namebuf));
305 		if (len < 0) {
306 			logger(LOG_ERR, "DNS query invalid message format");
307 			goto err;
308 		}
309 		ptr += len;
310 		NS_GET16(type, ptr);
311 		NS_GET16(class, ptr);
312 		NS_GET32(rttl, ptr);
313 		NS_GET16(size, ptr);
314 		if ((end = ptr + size) > eom) {
315 			logger(LOG_ERR, "DNS query invalid message format");
316 			goto err;
317 		}
318 
319 		if (type != T_SRV) {
320 			ptr = end;
321 			continue;
322 		}
323 
324 		NS_GET16(cds->cds_ds.priority, ptr);
325 		NS_GET16(cds->cds_ds.weight, ptr);
326 		NS_GET16(cds->cds_ds.port, ptr);
327 		len = dn_expand(msg, eom, ptr, cds->cds_ds.host,
328 		    sizeof (cds->cds_ds.host));
329 		if (len < 0) {
330 			logger(LOG_ERR, "DNS query invalid SRV record");
331 			goto err;
332 		}
333 
334 		cds->cds_ds.ttl = rttl;
335 
336 		if (DBG(DNS, 2)) {
337 			logger(LOG_DEBUG, "    %s", namebuf);
338 			logger(LOG_DEBUG,
339 			    "        ttl=%d pri=%d weight=%d %s:%d",
340 			    rttl, cds->cds_ds.priority, cds->cds_ds.weight,
341 			    cds->cds_ds.host, cds->cds_ds.port);
342 		}
343 		cds++;
344 
345 		/* move ptr to the end of current record */
346 		ptr = end;
347 	}
348 	*scnt = (cds - cds_res);
349 
350 	/* skip the nameservers section (if any) */
351 
352 	len = ns_skiprr(ptr, eom, ns_s_ns, nscount);
353 	if (len < 0) {
354 		logger(LOG_ERR, "DNS query invalid message format");
355 		goto err;
356 	}
357 	ptr += len;
358 
359 	/* walk through the additional records */
360 	for (i = 0; i < arcount; i++) {
361 		sa_family_t af;
362 
363 		len = dn_expand(msg, eom, ptr, namebuf,
364 		    sizeof (namebuf));
365 		if (len < 0) {
366 			logger(LOG_ERR, "DNS query invalid message format");
367 			goto err;
368 		}
369 		ptr += len;
370 		NS_GET16(type, ptr);
371 		NS_GET16(class, ptr);
372 		NS_GET32(rttl, ptr);
373 		NS_GET16(size, ptr);
374 		if ((end = ptr + size) > eom) {
375 			logger(LOG_ERR, "DNS query invalid message format");
376 			goto err;
377 		}
378 		switch (type) {
379 		case ns_t_a:
380 			af = AF_INET;
381 			break;
382 		case ns_t_aaaa:
383 			af = AF_INET6;
384 			break;
385 		default:
386 			continue;
387 		}
388 
389 		if (DBG(DNS, 2)) {
390 			char abuf[INET6_ADDRSTRLEN];
391 			const char *ap;
392 
393 			ap = inet_ntop(af, ptr, abuf, sizeof (abuf));
394 			logger(LOG_DEBUG, "    %s    %s    %s",
395 			    (af == AF_INET) ? "A   " : "AAAA",
396 			    (ap) ? ap : "?", namebuf);
397 		}
398 
399 		/* Find the server, add to its address list. */
400 		for (cds = cds_res; cds->cds_ds.host[0] != '\0'; cds++)
401 			if (0 == strcmp(namebuf, cds->cds_ds.host))
402 				save_addr(cds, af, ptr, size);
403 
404 		/* move ptr to the end of current record */
405 		ptr = end;
406 	}
407 
408 	return (cds_res);
409 
410 err:
411 	free(cds_res);
412 	return (NULL);
413 }
414 
415 /*
416  * Save this address on the server, if not already there.
417  */
418 static void
419 save_addr(ad_disc_cds_t *cds, sa_family_t af, uchar_t *addr, size_t alen)
420 {
421 	struct addrinfo *ai, *new_ai, *last_ai;
422 
423 	new_ai = make_addrinfo(af, addr, alen);
424 	if (new_ai == NULL)
425 		return;
426 
427 	last_ai = NULL;
428 	for (ai = cds->cds_ai; ai != NULL; ai = ai->ai_next) {
429 		last_ai = ai;
430 
431 		if (new_ai->ai_family == ai->ai_family &&
432 		    new_ai->ai_addrlen == ai->ai_addrlen &&
433 		    0 == memcmp(new_ai->ai_addr, ai->ai_addr,
434 		    ai->ai_addrlen)) {
435 			/* it's already there */
436 			freeaddrinfo(new_ai);
437 			return;
438 		}
439 	}
440 
441 	/* Not found.  Append. */
442 	if (last_ai != NULL) {
443 		last_ai->ai_next = new_ai;
444 	} else {
445 		cds->cds_ai = new_ai;
446 	}
447 }
448 
449 static struct addrinfo *
450 make_addrinfo(sa_family_t af, uchar_t *addr, size_t alen)
451 {
452 	struct addrinfo *ai;
453 	struct sockaddr *sa;
454 	struct sockaddr_in *sin;
455 	struct sockaddr_in6 *sin6;
456 	int slen;
457 
458 	ai = calloc(1, sizeof (*ai));
459 	sa = calloc(1, sizeof (struct sockaddr_in6));
460 
461 	if (ai == NULL || sa == NULL) {
462 		logger(LOG_ERR, "Out of memory");
463 		goto errout;
464 	}
465 
466 	switch (af) {
467 	case AF_INET:
468 		sin = (void *)sa;
469 		if (alen < sizeof (in_addr_t)) {
470 			logger(LOG_ERR, "bad IPv4 addr len");
471 			goto errout;
472 		}
473 		alen = sizeof (in_addr_t);
474 		sin->sin_family = af;
475 		(void) memcpy(&sin->sin_addr, addr, alen);
476 		slen = sizeof (*sin);
477 		break;
478 
479 	case AF_INET6:
480 		sin6 = (void *)sa;
481 		if (alen < sizeof (in6_addr_t)) {
482 			logger(LOG_ERR, "bad IPv6 addr len");
483 			goto errout;
484 		}
485 		alen = sizeof (in6_addr_t);
486 		sin6->sin6_family = af;
487 		(void) memcpy(&sin6->sin6_addr, addr, alen);
488 		slen = sizeof (*sin6);
489 		break;
490 
491 	default:
492 		goto errout;
493 	}
494 
495 	ai->ai_family = af;
496 	ai->ai_addrlen = slen;
497 	ai->ai_addr = sa;
498 	sa->sa_family = af;
499 	return (ai);
500 
501 errout:
502 	free(ai);
503 	free(sa);
504 	return (NULL);
505 }
506 
507 /*
508  * Set a preferred candidate, which may already be in the list,
509  * in which case we just bump its priority, or else add it.
510  */
511 static void
512 add_preferred(ad_disc_cds_t *cds, ad_disc_ds_t *prefer, int *nds, int maxds)
513 {
514 	ad_disc_ds_t *ds;
515 	int i;
516 
517 	assert(*nds < maxds);
518 	for (i = 0; i < *nds; i++) {
519 		ds = &cds[i].cds_ds;
520 
521 		if (strcasecmp(ds->host, prefer->host) == 0) {
522 			/* Force this element to be sorted first. */
523 			ds->priority = 0;
524 			ds->weight = 200;
525 			return;
526 		}
527 	}
528 
529 	/*
530 	 * The preferred DC was not found in this DNS response,
531 	 * so add it.  Again arrange for it to be sorted first.
532 	 * Address info. is added later.
533 	 */
534 	ds = &cds[i].cds_ds;
535 	(void) memcpy(ds, prefer, sizeof (*ds));
536 	ds->priority = 0;
537 	ds->weight = 200;
538 	*nds = i + 1;
539 }
540 
541 /*
542  * Do another pass over the array to check for missing addresses and
543  * try resolving the names.  Normally, the DNS response from AD will
544  * have supplied additional address records for all the SRV records.
545  */
546 static void
547 get_addresses(ad_disc_cds_t *cds, int cnt)
548 {
549 	int i;
550 
551 	for (i = 0; i < cnt; i++) {
552 		if (cds[i].cds_ai == NULL) {
553 			do_getaddrinfo(&cds[i]);
554 		}
555 	}
556 }
557 
558 static void
559 do_getaddrinfo(ad_disc_cds_t *cds)
560 {
561 	struct addrinfo hints;
562 	struct addrinfo *ai;
563 	ad_disc_ds_t *ds;
564 	time_t t0, t1;
565 	int err;
566 
567 	(void) memset(&hints, 0, sizeof (hints));
568 	hints.ai_protocol = IPPROTO_TCP;
569 	hints.ai_socktype = SOCK_STREAM;
570 	ds = &cds->cds_ds;
571 
572 	/*
573 	 * This getaddrinfo call may take a LONG time, i.e. if our
574 	 * DNS servers are misconfigured or not responding.
575 	 * We need something like getaddrinfo_a(), with a timeout.
576 	 * For now, just log when this happens so we'll know
577 	 * if these calls are taking a long time.
578 	 */
579 	if (DBG(DNS, 2))
580 		logger(LOG_DEBUG, "getaddrinfo %s ...", ds->host);
581 	t0 = time(NULL);
582 	err = getaddrinfo(cds->cds_ds.host, NULL, &hints, &ai);
583 	t1 = time(NULL);
584 	if (DBG(DNS, 2))
585 		logger(LOG_DEBUG, "getaddrinfo %s rc=%d", ds->host, err);
586 	if (t1 > (t0 + 5)) {
587 		logger(LOG_WARNING, "Lookup host (%s) took %u sec. "
588 		    "(Check DNS settings)", ds->host, (int)(t1 - t0));
589 	}
590 	if (err != 0) {
591 		logger(LOG_ERR, "No address for host: %s (%s)",
592 		    ds->host, gai_strerror(err));
593 		/* Make this sort at the end. */
594 		ds->priority = 1 << 16;
595 		return;
596 	}
597 
598 	cds->cds_ai = ai;
599 }
600 
601 void
602 srv_free(ad_disc_cds_t *cds_vec)
603 {
604 	ad_disc_cds_t *cds;
605 
606 	for (cds = cds_vec; cds->cds_ds.host[0] != '\0'; cds++) {
607 		if (cds->cds_ai != NULL) {
608 			freeaddrinfo(cds->cds_ai);
609 		}
610 	}
611 	free(cds_vec);
612 }
613