19ed56434SDamien Miller /* $OpenBSD: getrrsetbyname.c,v 1.11 2007/10/11 18:36:41 jakob Exp $ */
2d9ec370aSDamien Miller 
3d9ec370aSDamien Miller /*
4d9ec370aSDamien Miller  * Copyright (c) 2001 Jakob Schlyter. All rights reserved.
5d9ec370aSDamien Miller  *
6d9ec370aSDamien Miller  * Redistribution and use in source and binary forms, with or without
7d9ec370aSDamien Miller  * modification, are permitted provided that the following conditions
8d9ec370aSDamien Miller  * are met:
9d9ec370aSDamien Miller  *
10d9ec370aSDamien Miller  * 1. Redistributions of source code must retain the above copyright
11d9ec370aSDamien Miller  *    notice, this list of conditions and the following disclaimer.
12d9ec370aSDamien Miller  *
13d9ec370aSDamien Miller  * 2. Redistributions in binary form must reproduce the above copyright
14d9ec370aSDamien Miller  *    notice, this list of conditions and the following disclaimer in the
15d9ec370aSDamien Miller  *    documentation and/or other materials provided with the distribution.
16d9ec370aSDamien Miller  *
17d9ec370aSDamien Miller  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18d9ec370aSDamien Miller  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19d9ec370aSDamien Miller  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20d9ec370aSDamien Miller  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21d9ec370aSDamien Miller  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22d9ec370aSDamien Miller  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23d9ec370aSDamien Miller  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24d9ec370aSDamien Miller  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25d9ec370aSDamien Miller  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26d9ec370aSDamien Miller  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27d9ec370aSDamien Miller  */
28d9ec370aSDamien Miller 
29d9ec370aSDamien Miller /*
30d9ec370aSDamien Miller  * Portions Copyright (c) 1999-2001 Internet Software Consortium.
31d9ec370aSDamien Miller  *
32d9ec370aSDamien Miller  * Permission to use, copy, modify, and distribute this software for any
33d9ec370aSDamien Miller  * purpose with or without fee is hereby granted, provided that the above
34d9ec370aSDamien Miller  * copyright notice and this permission notice appear in all copies.
35d9ec370aSDamien Miller  *
36d9ec370aSDamien Miller  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
37d9ec370aSDamien Miller  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
38d9ec370aSDamien Miller  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
39d9ec370aSDamien Miller  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
40d9ec370aSDamien Miller  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
41d9ec370aSDamien Miller  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
42d9ec370aSDamien Miller  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
43d9ec370aSDamien Miller  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
44d9ec370aSDamien Miller  */
45d9ec370aSDamien Miller 
467f24a0e6SDarren Tucker /* OPENBSD ORIGINAL: lib/libc/net/getrrsetbyname.c */
477f24a0e6SDarren Tucker 
48d9ec370aSDamien Miller #include "includes.h"
49d9ec370aSDamien Miller 
50*aa3cbd1bSDarren Tucker #if !defined (HAVE_GETRRSETBYNAME) && !defined (HAVE_LDNS)
51d9ec370aSDamien Miller 
52d8aec107SDarren Tucker #include <stdlib.h>
53b8fe89c4SDamien Miller #include <string.h>
54b8fe89c4SDamien Miller 
5546aa3e0cSDarren Tucker #include <netinet/in.h>
5646aa3e0cSDarren Tucker #include <arpa/inet.h>
5746aa3e0cSDarren Tucker 
58d9ec370aSDamien Miller #include "getrrsetbyname.h"
59d9ec370aSDamien Miller 
60991d95f4SDarren Tucker #if defined(HAVE_DECL_H_ERRNO) && !HAVE_DECL_H_ERRNO
615bb14001SDarren Tucker extern int h_errno;
625bb14001SDarren Tucker #endif
635bb14001SDarren Tucker 
649b59ada7SDamien Miller /* We don't need multithread support here */
659b59ada7SDamien Miller #ifdef _THREAD_PRIVATE
669b59ada7SDamien Miller # undef _THREAD_PRIVATE
679b59ada7SDamien Miller #endif
689b59ada7SDamien Miller #define _THREAD_PRIVATE(a,b,c) (c)
6913c539a4SDarren Tucker 
70cc40d5ecSDarren Tucker #ifndef HAVE__RES_EXTERN
719b59ada7SDamien Miller struct __res_state _res;
72cc40d5ecSDarren Tucker #endif
73d9ec370aSDamien Miller 
749b59ada7SDamien Miller /* Necessary functions and macros */
75d9ec370aSDamien Miller 
76d9ec370aSDamien Miller /*
77d9ec370aSDamien Miller  * Inline versions of get/put short/long.  Pointer is advanced.
78d9ec370aSDamien Miller  *
79d9ec370aSDamien Miller  * These macros demonstrate the property of C whereby it can be
80d9ec370aSDamien Miller  * portable or it can be elegant but rarely both.
81d9ec370aSDamien Miller  */
82d9ec370aSDamien Miller 
83d9ec370aSDamien Miller #ifndef INT32SZ
84d9ec370aSDamien Miller # define INT32SZ	4
85d9ec370aSDamien Miller #endif
86d9ec370aSDamien Miller #ifndef INT16SZ
87d9ec370aSDamien Miller # define INT16SZ	2
88d9ec370aSDamien Miller #endif
89d9ec370aSDamien Miller 
90d9ec370aSDamien Miller #ifndef GETSHORT
91d9ec370aSDamien Miller #define GETSHORT(s, cp) { \
92d9ec370aSDamien Miller 	register u_char *t_cp = (u_char *)(cp); \
93d9ec370aSDamien Miller 	(s) = ((u_int16_t)t_cp[0] << 8) \
94d9ec370aSDamien Miller 	    | ((u_int16_t)t_cp[1]) \
95d9ec370aSDamien Miller 	    ; \
96d9ec370aSDamien Miller 	(cp) += INT16SZ; \
97d9ec370aSDamien Miller }
98d9ec370aSDamien Miller #endif
99d9ec370aSDamien Miller 
100d9ec370aSDamien Miller #ifndef GETLONG
101d9ec370aSDamien Miller #define GETLONG(l, cp) { \
102d9ec370aSDamien Miller 	register u_char *t_cp = (u_char *)(cp); \
103d9ec370aSDamien Miller 	(l) = ((u_int32_t)t_cp[0] << 24) \
104d9ec370aSDamien Miller 	    | ((u_int32_t)t_cp[1] << 16) \
105d9ec370aSDamien Miller 	    | ((u_int32_t)t_cp[2] << 8) \
106d9ec370aSDamien Miller 	    | ((u_int32_t)t_cp[3]) \
107d9ec370aSDamien Miller 	    ; \
108d9ec370aSDamien Miller 	(cp) += INT32SZ; \
109d9ec370aSDamien Miller }
110d9ec370aSDamien Miller #endif
111d9ec370aSDamien Miller 
112d9ec370aSDamien Miller /*
113d9ec370aSDamien Miller  * Routines to insert/extract short/long's.
114d9ec370aSDamien Miller  */
115d9ec370aSDamien Miller 
1160ac16a44STim Rice #ifndef HAVE__GETSHORT
117d9ec370aSDamien Miller static u_int16_t
_getshort(msgp)118d9ec370aSDamien Miller _getshort(msgp)
119d9ec370aSDamien Miller 	register const u_char *msgp;
120d9ec370aSDamien Miller {
121d9ec370aSDamien Miller 	register u_int16_t u;
122d9ec370aSDamien Miller 
123d9ec370aSDamien Miller 	GETSHORT(u, msgp);
124d9ec370aSDamien Miller 	return (u);
125d9ec370aSDamien Miller }
12684ce9b45SDarren Tucker #elif defined(HAVE_DECL__GETSHORT) && (HAVE_DECL__GETSHORT == 0)
12784ce9b45SDarren Tucker u_int16_t _getshort(register const u_char *);
1280ac16a44STim Rice #endif
129d9ec370aSDamien Miller 
1300ac16a44STim Rice #ifndef HAVE__GETLONG
131d9ec370aSDamien Miller static u_int32_t
_getlong(msgp)132d9ec370aSDamien Miller _getlong(msgp)
133d9ec370aSDamien Miller 	register const u_char *msgp;
134d9ec370aSDamien Miller {
135d9ec370aSDamien Miller 	register u_int32_t u;
136d9ec370aSDamien Miller 
137d9ec370aSDamien Miller 	GETLONG(u, msgp);
138d9ec370aSDamien Miller 	return (u);
139d9ec370aSDamien Miller }
14084ce9b45SDarren Tucker #elif defined(HAVE_DECL__GETLONG) && (HAVE_DECL__GETLONG == 0)
14184ce9b45SDarren Tucker u_int32_t _getlong(register const u_char *);
1420ac16a44STim Rice #endif
143d9ec370aSDamien Miller 
1449b59ada7SDamien Miller /* ************** */
1459b59ada7SDamien Miller 
146440089afSDarren Tucker #define ANSWER_BUFFER_SIZE 0xffff
1479b59ada7SDamien Miller 
1489b59ada7SDamien Miller struct dns_query {
1499b59ada7SDamien Miller 	char			*name;
1509b59ada7SDamien Miller 	u_int16_t		type;
1519b59ada7SDamien Miller 	u_int16_t		class;
1529b59ada7SDamien Miller 	struct dns_query	*next;
1539b59ada7SDamien Miller };
1549b59ada7SDamien Miller 
1559b59ada7SDamien Miller struct dns_rr {
1569b59ada7SDamien Miller 	char			*name;
1579b59ada7SDamien Miller 	u_int16_t		type;
1589b59ada7SDamien Miller 	u_int16_t		class;
1599b59ada7SDamien Miller 	u_int16_t		ttl;
1609b59ada7SDamien Miller 	u_int16_t		size;
1619b59ada7SDamien Miller 	void			*rdata;
1629b59ada7SDamien Miller 	struct dns_rr		*next;
1639b59ada7SDamien Miller };
1649b59ada7SDamien Miller 
1659b59ada7SDamien Miller struct dns_response {
1669b59ada7SDamien Miller 	HEADER			header;
1679b59ada7SDamien Miller 	struct dns_query	*query;
1689b59ada7SDamien Miller 	struct dns_rr		*answer;
1699b59ada7SDamien Miller 	struct dns_rr		*authority;
1709b59ada7SDamien Miller 	struct dns_rr		*additional;
1719b59ada7SDamien Miller };
1729b59ada7SDamien Miller 
1739b59ada7SDamien Miller static struct dns_response *parse_dns_response(const u_char *, int);
1749b59ada7SDamien Miller static struct dns_query *parse_dns_qsection(const u_char *, int,
1759b59ada7SDamien Miller     const u_char **, int);
1769b59ada7SDamien Miller static struct dns_rr *parse_dns_rrsection(const u_char *, int, const u_char **,
1779b59ada7SDamien Miller     int);
1789b59ada7SDamien Miller 
1799b59ada7SDamien Miller static void free_dns_query(struct dns_query *);
1809b59ada7SDamien Miller static void free_dns_rr(struct dns_rr *);
1819b59ada7SDamien Miller static void free_dns_response(struct dns_response *);
1829b59ada7SDamien Miller 
1839b59ada7SDamien Miller static int count_dns_rr(struct dns_rr *, u_int16_t, u_int16_t);
1849b59ada7SDamien Miller 
185d9ec370aSDamien Miller int
getrrsetbyname(const char * hostname,unsigned int rdclass,unsigned int rdtype,unsigned int flags,struct rrsetinfo ** res)186d9ec370aSDamien Miller getrrsetbyname(const char *hostname, unsigned int rdclass,
187d9ec370aSDamien Miller     unsigned int rdtype, unsigned int flags,
188d9ec370aSDamien Miller     struct rrsetinfo **res)
189d9ec370aSDamien Miller {
1909b59ada7SDamien Miller 	struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
191d9ec370aSDamien Miller 	int result;
192d9ec370aSDamien Miller 	struct rrsetinfo *rrset = NULL;
1939b59ada7SDamien Miller 	struct dns_response *response = NULL;
194d9ec370aSDamien Miller 	struct dns_rr *rr;
195d9ec370aSDamien Miller 	struct rdatainfo *rdata;
196e323df6cSDamien Miller 	int length;
197e323df6cSDamien Miller 	unsigned int index_ans, index_sig;
198e323df6cSDamien Miller 	u_char answer[ANSWER_BUFFER_SIZE];
199d9ec370aSDamien Miller 
200d9ec370aSDamien Miller 	/* check for invalid class and type */
201d9ec370aSDamien Miller 	if (rdclass > 0xffff || rdtype > 0xffff) {
202d9ec370aSDamien Miller 		result = ERRSET_INVAL;
203d9ec370aSDamien Miller 		goto fail;
204d9ec370aSDamien Miller 	}
205d9ec370aSDamien Miller 
206d9ec370aSDamien Miller 	/* don't allow queries of class or type ANY */
207d9ec370aSDamien Miller 	if (rdclass == 0xff || rdtype == 0xff) {
208d9ec370aSDamien Miller 		result = ERRSET_INVAL;
209d9ec370aSDamien Miller 		goto fail;
210d9ec370aSDamien Miller 	}
211d9ec370aSDamien Miller 
212d9ec370aSDamien Miller 	/* don't allow flags yet, unimplemented */
213d9ec370aSDamien Miller 	if (flags) {
214d9ec370aSDamien Miller 		result = ERRSET_INVAL;
215d9ec370aSDamien Miller 		goto fail;
216d9ec370aSDamien Miller 	}
217d9ec370aSDamien Miller 
218d9ec370aSDamien Miller 	/* initialize resolver */
2199b59ada7SDamien Miller 	if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
220d9ec370aSDamien Miller 		result = ERRSET_FAIL;
221d9ec370aSDamien Miller 		goto fail;
222d9ec370aSDamien Miller 	}
223d9ec370aSDamien Miller 
224d9ec370aSDamien Miller #ifdef DEBUG
2259b59ada7SDamien Miller 	_resp->options |= RES_DEBUG;
226d9ec370aSDamien Miller #endif /* DEBUG */
227d9ec370aSDamien Miller 
228d9ec370aSDamien Miller #ifdef RES_USE_DNSSEC
229d9ec370aSDamien Miller 	/* turn on DNSSEC if EDNS0 is configured */
2309b59ada7SDamien Miller 	if (_resp->options & RES_USE_EDNS0)
2319b59ada7SDamien Miller 		_resp->options |= RES_USE_DNSSEC;
232d9ec370aSDamien Miller #endif /* RES_USE_DNSEC */
233d9ec370aSDamien Miller 
234d9ec370aSDamien Miller 	/* make query */
235e323df6cSDamien Miller 	length = res_query(hostname, (signed int) rdclass, (signed int) rdtype,
236e323df6cSDamien Miller 	    answer, sizeof(answer));
237d9ec370aSDamien Miller 	if (length < 0) {
238d9ec370aSDamien Miller 		switch(h_errno) {
239d9ec370aSDamien Miller 		case HOST_NOT_FOUND:
240d9ec370aSDamien Miller 			result = ERRSET_NONAME;
241d9ec370aSDamien Miller 			goto fail;
242d9ec370aSDamien Miller 		case NO_DATA:
243d9ec370aSDamien Miller 			result = ERRSET_NODATA;
244d9ec370aSDamien Miller 			goto fail;
245d9ec370aSDamien Miller 		default:
246d9ec370aSDamien Miller 			result = ERRSET_FAIL;
247d9ec370aSDamien Miller 			goto fail;
248d9ec370aSDamien Miller 		}
249d9ec370aSDamien Miller 	}
250d9ec370aSDamien Miller 
251d9ec370aSDamien Miller 	/* parse result */
252d9ec370aSDamien Miller 	response = parse_dns_response(answer, length);
253d9ec370aSDamien Miller 	if (response == NULL) {
254d9ec370aSDamien Miller 		result = ERRSET_FAIL;
255d9ec370aSDamien Miller 		goto fail;
256d9ec370aSDamien Miller 	}
257d9ec370aSDamien Miller 
258d9ec370aSDamien Miller 	if (response->header.qdcount != 1) {
259d9ec370aSDamien Miller 		result = ERRSET_FAIL;
260d9ec370aSDamien Miller 		goto fail;
261d9ec370aSDamien Miller 	}
262d9ec370aSDamien Miller 
263d9ec370aSDamien Miller 	/* initialize rrset */
264d9ec370aSDamien Miller 	rrset = calloc(1, sizeof(struct rrsetinfo));
265d9ec370aSDamien Miller 	if (rrset == NULL) {
266d9ec370aSDamien Miller 		result = ERRSET_NOMEMORY;
267d9ec370aSDamien Miller 		goto fail;
268d9ec370aSDamien Miller 	}
269d9ec370aSDamien Miller 	rrset->rri_rdclass = response->query->class;
270d9ec370aSDamien Miller 	rrset->rri_rdtype = response->query->type;
271d9ec370aSDamien Miller 	rrset->rri_ttl = response->answer->ttl;
272d9ec370aSDamien Miller 	rrset->rri_nrdatas = response->header.ancount;
273d9ec370aSDamien Miller 
27416fd99c7SDarren Tucker #ifdef HAVE_HEADER_AD
275d9ec370aSDamien Miller 	/* check for authenticated data */
276d9ec370aSDamien Miller 	if (response->header.ad == 1)
277d9ec370aSDamien Miller 		rrset->rri_flags |= RRSET_VALIDATED;
27816fd99c7SDarren Tucker #endif
279d9ec370aSDamien Miller 
280d9ec370aSDamien Miller 	/* copy name from answer section */
2819b59ada7SDamien Miller 	rrset->rri_name = strdup(response->answer->name);
282d9ec370aSDamien Miller 	if (rrset->rri_name == NULL) {
283d9ec370aSDamien Miller 		result = ERRSET_NOMEMORY;
284d9ec370aSDamien Miller 		goto fail;
285d9ec370aSDamien Miller 	}
286d9ec370aSDamien Miller 
287d9ec370aSDamien Miller 	/* count answers */
288d9ec370aSDamien Miller 	rrset->rri_nrdatas = count_dns_rr(response->answer, rrset->rri_rdclass,
289d9ec370aSDamien Miller 	    rrset->rri_rdtype);
290d9ec370aSDamien Miller 	rrset->rri_nsigs = count_dns_rr(response->answer, rrset->rri_rdclass,
2919ed56434SDamien Miller 	    T_RRSIG);
292d9ec370aSDamien Miller 
293d9ec370aSDamien Miller 	/* allocate memory for answers */
294d9ec370aSDamien Miller 	rrset->rri_rdatas = calloc(rrset->rri_nrdatas,
295d9ec370aSDamien Miller 	    sizeof(struct rdatainfo));
296d9ec370aSDamien Miller 	if (rrset->rri_rdatas == NULL) {
297d9ec370aSDamien Miller 		result = ERRSET_NOMEMORY;
298d9ec370aSDamien Miller 		goto fail;
299d9ec370aSDamien Miller 	}
300d9ec370aSDamien Miller 
301d9ec370aSDamien Miller 	/* allocate memory for signatures */
30289ee69e3SDarren Tucker 	if (rrset->rri_nsigs > 0) {
303d9ec370aSDamien Miller 		rrset->rri_sigs = calloc(rrset->rri_nsigs, sizeof(struct rdatainfo));
3049b59ada7SDamien Miller 		if (rrset->rri_sigs == NULL) {
305d9ec370aSDamien Miller 			result = ERRSET_NOMEMORY;
306d9ec370aSDamien Miller 			goto fail;
307d9ec370aSDamien Miller 		}
30889ee69e3SDarren Tucker 	}
309d9ec370aSDamien Miller 
310d9ec370aSDamien Miller 	/* copy answers & signatures */
311d9ec370aSDamien Miller 	for (rr = response->answer, index_ans = 0, index_sig = 0;
312d9ec370aSDamien Miller 	    rr; rr = rr->next) {
313d9ec370aSDamien Miller 
314d9ec370aSDamien Miller 		rdata = NULL;
315d9ec370aSDamien Miller 
316d9ec370aSDamien Miller 		if (rr->class == rrset->rri_rdclass &&
317d9ec370aSDamien Miller 		    rr->type  == rrset->rri_rdtype)
318d9ec370aSDamien Miller 			rdata = &rrset->rri_rdatas[index_ans++];
319d9ec370aSDamien Miller 
320d9ec370aSDamien Miller 		if (rr->class == rrset->rri_rdclass &&
3219ed56434SDamien Miller 		    rr->type  == T_RRSIG)
322d9ec370aSDamien Miller 			rdata = &rrset->rri_sigs[index_sig++];
323d9ec370aSDamien Miller 
324d9ec370aSDamien Miller 		if (rdata) {
325d9ec370aSDamien Miller 			rdata->rdi_length = rr->size;
326d9ec370aSDamien Miller 			rdata->rdi_data   = malloc(rr->size);
327d9ec370aSDamien Miller 
328d9ec370aSDamien Miller 			if (rdata->rdi_data == NULL) {
329d9ec370aSDamien Miller 				result = ERRSET_NOMEMORY;
330d9ec370aSDamien Miller 				goto fail;
331d9ec370aSDamien Miller 			}
332d9ec370aSDamien Miller 			memcpy(rdata->rdi_data, rr->rdata, rr->size);
333d9ec370aSDamien Miller 		}
334d9ec370aSDamien Miller 	}
3359b59ada7SDamien Miller 	free_dns_response(response);
336d9ec370aSDamien Miller 
337d9ec370aSDamien Miller 	*res = rrset;
338d9ec370aSDamien Miller 	return (ERRSET_SUCCESS);
339d9ec370aSDamien Miller 
340d9ec370aSDamien Miller fail:
341d9ec370aSDamien Miller 	if (rrset != NULL)
342d9ec370aSDamien Miller 		freerrset(rrset);
3439b59ada7SDamien Miller 	if (response != NULL)
3449b59ada7SDamien Miller 		free_dns_response(response);
345d9ec370aSDamien Miller 	return (result);
346d9ec370aSDamien Miller }
347d9ec370aSDamien Miller 
348d9ec370aSDamien Miller void
freerrset(struct rrsetinfo * rrset)349d9ec370aSDamien Miller freerrset(struct rrsetinfo *rrset)
350d9ec370aSDamien Miller {
351d9ec370aSDamien Miller 	u_int16_t i;
352d9ec370aSDamien Miller 
353d9ec370aSDamien Miller 	if (rrset == NULL)
354d9ec370aSDamien Miller 		return;
355d9ec370aSDamien Miller 
356d9ec370aSDamien Miller 	if (rrset->rri_rdatas) {
357d9ec370aSDamien Miller 		for (i = 0; i < rrset->rri_nrdatas; i++) {
358d9ec370aSDamien Miller 			if (rrset->rri_rdatas[i].rdi_data == NULL)
359d9ec370aSDamien Miller 				break;
360d9ec370aSDamien Miller 			free(rrset->rri_rdatas[i].rdi_data);
361d9ec370aSDamien Miller 		}
362d9ec370aSDamien Miller 		free(rrset->rri_rdatas);
363d9ec370aSDamien Miller 	}
364d9ec370aSDamien Miller 
365d9ec370aSDamien Miller 	if (rrset->rri_sigs) {
366d9ec370aSDamien Miller 		for (i = 0; i < rrset->rri_nsigs; i++) {
367d9ec370aSDamien Miller 			if (rrset->rri_sigs[i].rdi_data == NULL)
368d9ec370aSDamien Miller 				break;
369d9ec370aSDamien Miller 			free(rrset->rri_sigs[i].rdi_data);
370d9ec370aSDamien Miller 		}
371d9ec370aSDamien Miller 		free(rrset->rri_sigs);
372d9ec370aSDamien Miller 	}
373d9ec370aSDamien Miller 
374d9ec370aSDamien Miller 	if (rrset->rri_name)
375d9ec370aSDamien Miller 		free(rrset->rri_name);
376d9ec370aSDamien Miller 	free(rrset);
377d9ec370aSDamien Miller }
378d9ec370aSDamien Miller 
379d9ec370aSDamien Miller /*
380d9ec370aSDamien Miller  * DNS response parsing routines
381d9ec370aSDamien Miller  */
382d9ec370aSDamien Miller static struct dns_response *
parse_dns_response(const u_char * answer,int size)383e323df6cSDamien Miller parse_dns_response(const u_char *answer, int size)
384d9ec370aSDamien Miller {
385d9ec370aSDamien Miller 	struct dns_response *resp;
386e323df6cSDamien Miller 	const u_char *cp;
387d9ec370aSDamien Miller 
388d9ec370aSDamien Miller 	/* allocate memory for the response */
389d9ec370aSDamien Miller 	resp = calloc(1, sizeof(*resp));
390d9ec370aSDamien Miller 	if (resp == NULL)
391d9ec370aSDamien Miller 		return (NULL);
392d9ec370aSDamien Miller 
393d9ec370aSDamien Miller 	/* initialize current pointer */
394d9ec370aSDamien Miller 	cp = answer;
395d9ec370aSDamien Miller 
396d9ec370aSDamien Miller 	/* copy header */
397d9ec370aSDamien Miller 	memcpy(&resp->header, cp, HFIXEDSZ);
398d9ec370aSDamien Miller 	cp += HFIXEDSZ;
399d9ec370aSDamien Miller 
400d9ec370aSDamien Miller 	/* fix header byte order */
401d9ec370aSDamien Miller 	resp->header.qdcount = ntohs(resp->header.qdcount);
402d9ec370aSDamien Miller 	resp->header.ancount = ntohs(resp->header.ancount);
403d9ec370aSDamien Miller 	resp->header.nscount = ntohs(resp->header.nscount);
404d9ec370aSDamien Miller 	resp->header.arcount = ntohs(resp->header.arcount);
405d9ec370aSDamien Miller 
406d9ec370aSDamien Miller 	/* there must be at least one query */
407d9ec370aSDamien Miller 	if (resp->header.qdcount < 1) {
408d9ec370aSDamien Miller 		free_dns_response(resp);
409d9ec370aSDamien Miller 		return (NULL);
410d9ec370aSDamien Miller 	}
411d9ec370aSDamien Miller 
412d9ec370aSDamien Miller 	/* parse query section */
413d9ec370aSDamien Miller 	resp->query = parse_dns_qsection(answer, size, &cp,
414d9ec370aSDamien Miller 	    resp->header.qdcount);
415d9ec370aSDamien Miller 	if (resp->header.qdcount && resp->query == NULL) {
416d9ec370aSDamien Miller 		free_dns_response(resp);
417d9ec370aSDamien Miller 		return (NULL);
418d9ec370aSDamien Miller 	}
419d9ec370aSDamien Miller 
420d9ec370aSDamien Miller 	/* parse answer section */
421d9ec370aSDamien Miller 	resp->answer = parse_dns_rrsection(answer, size, &cp,
422d9ec370aSDamien Miller 	    resp->header.ancount);
423d9ec370aSDamien Miller 	if (resp->header.ancount && resp->answer == NULL) {
424d9ec370aSDamien Miller 		free_dns_response(resp);
425d9ec370aSDamien Miller 		return (NULL);
426d9ec370aSDamien Miller 	}
427d9ec370aSDamien Miller 
428d9ec370aSDamien Miller 	/* parse authority section */
429d9ec370aSDamien Miller 	resp->authority = parse_dns_rrsection(answer, size, &cp,
430d9ec370aSDamien Miller 	    resp->header.nscount);
431d9ec370aSDamien Miller 	if (resp->header.nscount && resp->authority == NULL) {
432d9ec370aSDamien Miller 		free_dns_response(resp);
433d9ec370aSDamien Miller 		return (NULL);
434d9ec370aSDamien Miller 	}
435d9ec370aSDamien Miller 
436d9ec370aSDamien Miller 	/* parse additional section */
437d9ec370aSDamien Miller 	resp->additional = parse_dns_rrsection(answer, size, &cp,
438d9ec370aSDamien Miller 	    resp->header.arcount);
439d9ec370aSDamien Miller 	if (resp->header.arcount && resp->additional == NULL) {
440d9ec370aSDamien Miller 		free_dns_response(resp);
441d9ec370aSDamien Miller 		return (NULL);
442d9ec370aSDamien Miller 	}
443d9ec370aSDamien Miller 
444d9ec370aSDamien Miller 	return (resp);
445d9ec370aSDamien Miller }
446d9ec370aSDamien Miller 
447d9ec370aSDamien Miller static struct dns_query *
parse_dns_qsection(const u_char * answer,int size,const u_char ** cp,int count)448e323df6cSDamien Miller parse_dns_qsection(const u_char *answer, int size, const u_char **cp, int count)
449d9ec370aSDamien Miller {
450d9ec370aSDamien Miller 	struct dns_query *head, *curr, *prev;
451d9ec370aSDamien Miller 	int i, length;
452d9ec370aSDamien Miller 	char name[MAXDNAME];
453d9ec370aSDamien Miller 
454d9ec370aSDamien Miller 	for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
455d9ec370aSDamien Miller 
456d9ec370aSDamien Miller 		/* allocate and initialize struct */
457d9ec370aSDamien Miller 		curr = calloc(1, sizeof(struct dns_query));
458d9ec370aSDamien Miller 		if (curr == NULL) {
459d9ec370aSDamien Miller 			free_dns_query(head);
460d9ec370aSDamien Miller 			return (NULL);
461d9ec370aSDamien Miller 		}
462d9ec370aSDamien Miller 		if (head == NULL)
463d9ec370aSDamien Miller 			head = curr;
464d9ec370aSDamien Miller 		if (prev != NULL)
465d9ec370aSDamien Miller 			prev->next = curr;
466d9ec370aSDamien Miller 
467d9ec370aSDamien Miller 		/* name */
468d9ec370aSDamien Miller 		length = dn_expand(answer, answer + size, *cp, name,
469d9ec370aSDamien Miller 		    sizeof(name));
470d9ec370aSDamien Miller 		if (length < 0) {
471d9ec370aSDamien Miller 			free_dns_query(head);
472d9ec370aSDamien Miller 			return (NULL);
473d9ec370aSDamien Miller 		}
474d9ec370aSDamien Miller 		curr->name = strdup(name);
475d9ec370aSDamien Miller 		if (curr->name == NULL) {
476d9ec370aSDamien Miller 			free_dns_query(head);
477d9ec370aSDamien Miller 			return (NULL);
478d9ec370aSDamien Miller 		}
479d9ec370aSDamien Miller 		*cp += length;
480d9ec370aSDamien Miller 
481d9ec370aSDamien Miller 		/* type */
482d9ec370aSDamien Miller 		curr->type = _getshort(*cp);
483d9ec370aSDamien Miller 		*cp += INT16SZ;
484d9ec370aSDamien Miller 
485d9ec370aSDamien Miller 		/* class */
486d9ec370aSDamien Miller 		curr->class = _getshort(*cp);
487d9ec370aSDamien Miller 		*cp += INT16SZ;
488d9ec370aSDamien Miller 	}
489d9ec370aSDamien Miller 
490d9ec370aSDamien Miller 	return (head);
491d9ec370aSDamien Miller }
492d9ec370aSDamien Miller 
493d9ec370aSDamien Miller static struct dns_rr *
parse_dns_rrsection(const u_char * answer,int size,const u_char ** cp,int count)4949b59ada7SDamien Miller parse_dns_rrsection(const u_char *answer, int size, const u_char **cp,
4959b59ada7SDamien Miller     int count)
496d9ec370aSDamien Miller {
497d9ec370aSDamien Miller 	struct dns_rr *head, *curr, *prev;
498d9ec370aSDamien Miller 	int i, length;
499d9ec370aSDamien Miller 	char name[MAXDNAME];
500d9ec370aSDamien Miller 
501d9ec370aSDamien Miller 	for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
502d9ec370aSDamien Miller 
503d9ec370aSDamien Miller 		/* allocate and initialize struct */
504d9ec370aSDamien Miller 		curr = calloc(1, sizeof(struct dns_rr));
505d9ec370aSDamien Miller 		if (curr == NULL) {
506d9ec370aSDamien Miller 			free_dns_rr(head);
507d9ec370aSDamien Miller 			return (NULL);
508d9ec370aSDamien Miller 		}
509d9ec370aSDamien Miller 		if (head == NULL)
510d9ec370aSDamien Miller 			head = curr;
511d9ec370aSDamien Miller 		if (prev != NULL)
512d9ec370aSDamien Miller 			prev->next = curr;
513d9ec370aSDamien Miller 
514d9ec370aSDamien Miller 		/* name */
515d9ec370aSDamien Miller 		length = dn_expand(answer, answer + size, *cp, name,
516d9ec370aSDamien Miller 		    sizeof(name));
517d9ec370aSDamien Miller 		if (length < 0) {
518d9ec370aSDamien Miller 			free_dns_rr(head);
519d9ec370aSDamien Miller 			return (NULL);
520d9ec370aSDamien Miller 		}
521d9ec370aSDamien Miller 		curr->name = strdup(name);
522d9ec370aSDamien Miller 		if (curr->name == NULL) {
523d9ec370aSDamien Miller 			free_dns_rr(head);
524d9ec370aSDamien Miller 			return (NULL);
525d9ec370aSDamien Miller 		}
526d9ec370aSDamien Miller 		*cp += length;
527d9ec370aSDamien Miller 
528d9ec370aSDamien Miller 		/* type */
529d9ec370aSDamien Miller 		curr->type = _getshort(*cp);
530d9ec370aSDamien Miller 		*cp += INT16SZ;
531d9ec370aSDamien Miller 
532d9ec370aSDamien Miller 		/* class */
533d9ec370aSDamien Miller 		curr->class = _getshort(*cp);
534d9ec370aSDamien Miller 		*cp += INT16SZ;
535d9ec370aSDamien Miller 
536d9ec370aSDamien Miller 		/* ttl */
537d9ec370aSDamien Miller 		curr->ttl = _getlong(*cp);
538d9ec370aSDamien Miller 		*cp += INT32SZ;
539d9ec370aSDamien Miller 
540d9ec370aSDamien Miller 		/* rdata size */
541d9ec370aSDamien Miller 		curr->size = _getshort(*cp);
542d9ec370aSDamien Miller 		*cp += INT16SZ;
543d9ec370aSDamien Miller 
544d9ec370aSDamien Miller 		/* rdata itself */
545d9ec370aSDamien Miller 		curr->rdata = malloc(curr->size);
546d9ec370aSDamien Miller 		if (curr->rdata == NULL) {
547d9ec370aSDamien Miller 			free_dns_rr(head);
548d9ec370aSDamien Miller 			return (NULL);
549d9ec370aSDamien Miller 		}
550d9ec370aSDamien Miller 		memcpy(curr->rdata, *cp, curr->size);
551d9ec370aSDamien Miller 		*cp += curr->size;
552d9ec370aSDamien Miller 	}
553d9ec370aSDamien Miller 
554d9ec370aSDamien Miller 	return (head);
555d9ec370aSDamien Miller }
556d9ec370aSDamien Miller 
557d9ec370aSDamien Miller static void
free_dns_query(struct dns_query * p)558d9ec370aSDamien Miller free_dns_query(struct dns_query *p)
559d9ec370aSDamien Miller {
560d9ec370aSDamien Miller 	if (p == NULL)
561d9ec370aSDamien Miller 		return;
562d9ec370aSDamien Miller 
563d9ec370aSDamien Miller 	if (p->name)
564d9ec370aSDamien Miller 		free(p->name);
565d9ec370aSDamien Miller 	free_dns_query(p->next);
566d9ec370aSDamien Miller 	free(p);
567d9ec370aSDamien Miller }
568d9ec370aSDamien Miller 
569d9ec370aSDamien Miller static void
free_dns_rr(struct dns_rr * p)570d9ec370aSDamien Miller free_dns_rr(struct dns_rr *p)
571d9ec370aSDamien Miller {
572d9ec370aSDamien Miller 	if (p == NULL)
573d9ec370aSDamien Miller 		return;
574d9ec370aSDamien Miller 
575d9ec370aSDamien Miller 	if (p->name)
576d9ec370aSDamien Miller 		free(p->name);
577d9ec370aSDamien Miller 	if (p->rdata)
578d9ec370aSDamien Miller 		free(p->rdata);
579d9ec370aSDamien Miller 	free_dns_rr(p->next);
580d9ec370aSDamien Miller 	free(p);
581d9ec370aSDamien Miller }
582d9ec370aSDamien Miller 
583d9ec370aSDamien Miller static void
free_dns_response(struct dns_response * p)584d9ec370aSDamien Miller free_dns_response(struct dns_response *p)
585d9ec370aSDamien Miller {
586d9ec370aSDamien Miller 	if (p == NULL)
587d9ec370aSDamien Miller 		return;
588d9ec370aSDamien Miller 
589d9ec370aSDamien Miller 	free_dns_query(p->query);
590d9ec370aSDamien Miller 	free_dns_rr(p->answer);
591d9ec370aSDamien Miller 	free_dns_rr(p->authority);
592d9ec370aSDamien Miller 	free_dns_rr(p->additional);
593d9ec370aSDamien Miller 	free(p);
594d9ec370aSDamien Miller }
595d9ec370aSDamien Miller 
596d9ec370aSDamien Miller static int
count_dns_rr(struct dns_rr * p,u_int16_t class,u_int16_t type)597d9ec370aSDamien Miller count_dns_rr(struct dns_rr *p, u_int16_t class, u_int16_t type)
598d9ec370aSDamien Miller {
599d9ec370aSDamien Miller 	int n = 0;
600d9ec370aSDamien Miller 
601d9ec370aSDamien Miller 	while(p) {
602d9ec370aSDamien Miller 		if (p->class == class && p->type == type)
603d9ec370aSDamien Miller 			n++;
604d9ec370aSDamien Miller 		p = p->next;
605d9ec370aSDamien Miller 	}
606d9ec370aSDamien Miller 
607d9ec370aSDamien Miller 	return (n);
608d9ec370aSDamien Miller }
609d9ec370aSDamien Miller 
610*aa3cbd1bSDarren Tucker #endif /*  !defined (HAVE_GETRRSETBYNAME) && !defined (HAVE_LDNS) */
611