1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2012-2013 The FreeBSD Foundation
5 * All rights reserved.
6 *
7 * This software was developed by Pawel Jakub Dawidek under sponsorship from
8 * the FreeBSD Foundation.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD$");
34
35#include <sys/dnv.h>
36#include <sys/nv.h>
37#include <netinet/in.h>
38
39#include <assert.h>
40#include <errno.h>
41#include <netdb.h>
42#include <stdlib.h>
43#include <string.h>
44#include <unistd.h>
45
46#include <libcasper.h>
47#include <libcasper_service.h>
48
49#include "cap_dns.h"
50
51static struct hostent hent;
52
53static void
54hostent_free(struct hostent *hp)
55{
56	unsigned int ii;
57
58	free(hp->h_name);
59	hp->h_name = NULL;
60	if (hp->h_aliases != NULL) {
61		for (ii = 0; hp->h_aliases[ii] != NULL; ii++)
62			free(hp->h_aliases[ii]);
63		free(hp->h_aliases);
64		hp->h_aliases = NULL;
65	}
66	if (hp->h_addr_list != NULL) {
67		for (ii = 0; hp->h_addr_list[ii] != NULL; ii++)
68			free(hp->h_addr_list[ii]);
69		free(hp->h_addr_list);
70		hp->h_addr_list = NULL;
71	}
72}
73
74static struct hostent *
75hostent_unpack(const nvlist_t *nvl, struct hostent *hp)
76{
77	unsigned int ii, nitems;
78	char nvlname[64];
79	int n;
80
81	hostent_free(hp);
82
83	hp->h_name = strdup(nvlist_get_string(nvl, "name"));
84	if (hp->h_name == NULL)
85		goto fail;
86	hp->h_addrtype = (int)nvlist_get_number(nvl, "addrtype");
87	hp->h_length = (int)nvlist_get_number(nvl, "length");
88
89	nitems = (unsigned int)nvlist_get_number(nvl, "naliases");
90	hp->h_aliases = calloc(sizeof(hp->h_aliases[0]), nitems + 1);
91	if (hp->h_aliases == NULL)
92		goto fail;
93	for (ii = 0; ii < nitems; ii++) {
94		n = snprintf(nvlname, sizeof(nvlname), "alias%u", ii);
95		assert(n > 0 && n < (int)sizeof(nvlname));
96		hp->h_aliases[ii] =
97		    strdup(nvlist_get_string(nvl, nvlname));
98		if (hp->h_aliases[ii] == NULL)
99			goto fail;
100	}
101	hp->h_aliases[ii] = NULL;
102
103	nitems = (unsigned int)nvlist_get_number(nvl, "naddrs");
104	hp->h_addr_list = calloc(sizeof(hp->h_addr_list[0]), nitems + 1);
105	if (hp->h_addr_list == NULL)
106		goto fail;
107	for (ii = 0; ii < nitems; ii++) {
108		hp->h_addr_list[ii] = malloc(hp->h_length);
109		if (hp->h_addr_list[ii] == NULL)
110			goto fail;
111		n = snprintf(nvlname, sizeof(nvlname), "addr%u", ii);
112		assert(n > 0 && n < (int)sizeof(nvlname));
113		bcopy(nvlist_get_binary(nvl, nvlname, NULL),
114		    hp->h_addr_list[ii], hp->h_length);
115	}
116	hp->h_addr_list[ii] = NULL;
117
118	return (hp);
119fail:
120	hostent_free(hp);
121	h_errno = NO_RECOVERY;
122	return (NULL);
123}
124
125struct hostent *
126cap_gethostbyname(cap_channel_t *chan, const char *name)
127{
128
129	return (cap_gethostbyname2(chan, name, AF_INET));
130}
131
132struct hostent *
133cap_gethostbyname2(cap_channel_t *chan, const char *name, int type)
134{
135	struct hostent *hp;
136	nvlist_t *nvl;
137
138	nvl = nvlist_create(0);
139	nvlist_add_string(nvl, "cmd", "gethostbyname");
140	nvlist_add_number(nvl, "family", (uint64_t)type);
141	nvlist_add_string(nvl, "name", name);
142	nvl = cap_xfer_nvlist(chan, nvl);
143	if (nvl == NULL) {
144		h_errno = NO_RECOVERY;
145		return (NULL);
146	}
147	if (nvlist_get_number(nvl, "error") != 0) {
148		h_errno = (int)nvlist_get_number(nvl, "error");
149		nvlist_destroy(nvl);
150		return (NULL);
151	}
152
153	hp = hostent_unpack(nvl, &hent);
154	nvlist_destroy(nvl);
155	return (hp);
156}
157
158struct hostent *
159cap_gethostbyaddr(cap_channel_t *chan, const void *addr, socklen_t len,
160    int type)
161{
162	struct hostent *hp;
163	nvlist_t *nvl;
164
165	nvl = nvlist_create(0);
166	nvlist_add_string(nvl, "cmd", "gethostbyaddr");
167	nvlist_add_binary(nvl, "addr", addr, (size_t)len);
168	nvlist_add_number(nvl, "family", (uint64_t)type);
169	nvl = cap_xfer_nvlist(chan, nvl);
170	if (nvl == NULL) {
171		h_errno = NO_RECOVERY;
172		return (NULL);
173	}
174	if (nvlist_get_number(nvl, "error") != 0) {
175		h_errno = (int)nvlist_get_number(nvl, "error");
176		nvlist_destroy(nvl);
177		return (NULL);
178	}
179	hp = hostent_unpack(nvl, &hent);
180	nvlist_destroy(nvl);
181	return (hp);
182}
183
184static struct addrinfo *
185addrinfo_unpack(const nvlist_t *nvl)
186{
187	struct addrinfo *ai;
188	const void *addr;
189	size_t addrlen;
190	const char *canonname;
191
192	addr = nvlist_get_binary(nvl, "ai_addr", &addrlen);
193	ai = malloc(sizeof(*ai) + addrlen);
194	if (ai == NULL)
195		return (NULL);
196	ai->ai_flags = (int)nvlist_get_number(nvl, "ai_flags");
197	ai->ai_family = (int)nvlist_get_number(nvl, "ai_family");
198	ai->ai_socktype = (int)nvlist_get_number(nvl, "ai_socktype");
199	ai->ai_protocol = (int)nvlist_get_number(nvl, "ai_protocol");
200	ai->ai_addrlen = (socklen_t)addrlen;
201	canonname = dnvlist_get_string(nvl, "ai_canonname", NULL);
202	if (canonname != NULL) {
203		ai->ai_canonname = strdup(canonname);
204		if (ai->ai_canonname == NULL) {
205			free(ai);
206			return (NULL);
207		}
208	} else {
209		ai->ai_canonname = NULL;
210	}
211	ai->ai_addr = (void *)(ai + 1);
212	bcopy(addr, ai->ai_addr, addrlen);
213	ai->ai_next = NULL;
214
215	return (ai);
216}
217
218int
219cap_getaddrinfo(cap_channel_t *chan, const char *hostname, const char *servname,
220    const struct addrinfo *hints, struct addrinfo **res)
221{
222	struct addrinfo *firstai, *prevai, *curai;
223	unsigned int ii;
224	const nvlist_t *nvlai;
225	char nvlname[64];
226	nvlist_t *nvl;
227	int error, n;
228
229	nvl = nvlist_create(0);
230	nvlist_add_string(nvl, "cmd", "getaddrinfo");
231	if (hostname != NULL)
232		nvlist_add_string(nvl, "hostname", hostname);
233	if (servname != NULL)
234		nvlist_add_string(nvl, "servname", servname);
235	if (hints != NULL) {
236		nvlist_add_number(nvl, "hints.ai_flags",
237		    (uint64_t)hints->ai_flags);
238		nvlist_add_number(nvl, "hints.ai_family",
239		    (uint64_t)hints->ai_family);
240		nvlist_add_number(nvl, "hints.ai_socktype",
241		    (uint64_t)hints->ai_socktype);
242		nvlist_add_number(nvl, "hints.ai_protocol",
243		    (uint64_t)hints->ai_protocol);
244	}
245	nvl = cap_xfer_nvlist(chan, nvl);
246	if (nvl == NULL)
247		return (EAI_MEMORY);
248	if (nvlist_get_number(nvl, "error") != 0) {
249		error = (int)nvlist_get_number(nvl, "error");
250		nvlist_destroy(nvl);
251		return (error);
252	}
253
254	nvlai = NULL;
255	firstai = prevai = curai = NULL;
256	for (ii = 0; ; ii++) {
257		n = snprintf(nvlname, sizeof(nvlname), "res%u", ii);
258		assert(n > 0 && n < (int)sizeof(nvlname));
259		if (!nvlist_exists_nvlist(nvl, nvlname))
260			break;
261		nvlai = nvlist_get_nvlist(nvl, nvlname);
262		curai = addrinfo_unpack(nvlai);
263		if (curai == NULL)
264			break;
265		if (prevai != NULL)
266			prevai->ai_next = curai;
267		else if (firstai == NULL)
268			firstai = curai;
269		prevai = curai;
270	}
271	nvlist_destroy(nvl);
272	if (curai == NULL && nvlai != NULL) {
273		if (firstai == NULL)
274			freeaddrinfo(firstai);
275		return (EAI_MEMORY);
276	}
277
278	*res = firstai;
279	return (0);
280}
281
282int
283cap_getnameinfo(cap_channel_t *chan, const struct sockaddr *sa, socklen_t salen,
284    char *host, size_t hostlen, char *serv, size_t servlen, int flags)
285{
286	nvlist_t *nvl;
287	int error;
288
289	nvl = nvlist_create(0);
290	nvlist_add_string(nvl, "cmd", "getnameinfo");
291	nvlist_add_number(nvl, "hostlen", (uint64_t)hostlen);
292	nvlist_add_number(nvl, "servlen", (uint64_t)servlen);
293	nvlist_add_binary(nvl, "sa", sa, (size_t)salen);
294	nvlist_add_number(nvl, "flags", (uint64_t)flags);
295	nvl = cap_xfer_nvlist(chan, nvl);
296	if (nvl == NULL)
297		return (EAI_MEMORY);
298	if (nvlist_get_number(nvl, "error") != 0) {
299		error = (int)nvlist_get_number(nvl, "error");
300		nvlist_destroy(nvl);
301		return (error);
302	}
303
304	if (host != NULL && nvlist_exists_string(nvl, "host"))
305		strlcpy(host, nvlist_get_string(nvl, "host"), hostlen + 1);
306	if (serv != NULL && nvlist_exists_string(nvl, "serv"))
307		strlcpy(serv, nvlist_get_string(nvl, "serv"), servlen + 1);
308	nvlist_destroy(nvl);
309	return (0);
310}
311
312static void
313limit_remove(nvlist_t *limits, const char *prefix)
314{
315	const char *name;
316	size_t prefixlen;
317	void *cookie;
318
319	prefixlen = strlen(prefix);
320again:
321	cookie = NULL;
322	while ((name = nvlist_next(limits, NULL, &cookie)) != NULL) {
323		if (strncmp(name, prefix, prefixlen) == 0) {
324			nvlist_free(limits, name);
325			goto again;
326		}
327	}
328}
329
330int
331cap_dns_type_limit(cap_channel_t *chan, const char * const *types,
332    size_t ntypes)
333{
334	nvlist_t *limits;
335	unsigned int i;
336	char nvlname[64];
337	int n;
338
339	if (cap_limit_get(chan, &limits) < 0)
340		return (-1);
341	if (limits == NULL)
342		limits = nvlist_create(0);
343	else
344		limit_remove(limits, "type");
345	for (i = 0; i < ntypes; i++) {
346		n = snprintf(nvlname, sizeof(nvlname), "type%u", i);
347		assert(n > 0 && n < (int)sizeof(nvlname));
348		nvlist_add_string(limits, nvlname, types[i]);
349	}
350	return (cap_limit_set(chan, limits));
351}
352
353int
354cap_dns_family_limit(cap_channel_t *chan, const int *families,
355    size_t nfamilies)
356{
357	nvlist_t *limits;
358	unsigned int i;
359	char nvlname[64];
360	int n;
361
362	if (cap_limit_get(chan, &limits) < 0)
363		return (-1);
364	if (limits == NULL)
365		limits = nvlist_create(0);
366	else
367		limit_remove(limits, "family");
368	for (i = 0; i < nfamilies; i++) {
369		n = snprintf(nvlname, sizeof(nvlname), "family%u", i);
370		assert(n > 0 && n < (int)sizeof(nvlname));
371		nvlist_add_number(limits, nvlname, (uint64_t)families[i]);
372	}
373	return (cap_limit_set(chan, limits));
374}
375
376/*
377 * Service functions.
378 */
379static bool
380dns_allowed_type(const nvlist_t *limits, const char *type)
381{
382	const char *name;
383	bool notypes;
384	void *cookie;
385
386	if (limits == NULL)
387		return (true);
388
389	notypes = true;
390	cookie = NULL;
391	while ((name = nvlist_next(limits, NULL, &cookie)) != NULL) {
392		if (strncmp(name, "type", sizeof("type") - 1) != 0)
393			continue;
394		notypes = false;
395		if (strcmp(nvlist_get_string(limits, name), type) == 0)
396			return (true);
397	}
398
399	/* If there are no types at all, allow any type. */
400	if (notypes)
401		return (true);
402
403	return (false);
404}
405
406static bool
407dns_allowed_family(const nvlist_t *limits, int family)
408{
409	const char *name;
410	bool nofamilies;
411	void *cookie;
412
413	if (limits == NULL)
414		return (true);
415
416	nofamilies = true;
417	cookie = NULL;
418	while ((name = nvlist_next(limits, NULL, &cookie)) != NULL) {
419		if (strncmp(name, "family", sizeof("family") - 1) != 0)
420			continue;
421		nofamilies = false;
422		if (family == AF_UNSPEC)
423			continue;
424		if (nvlist_get_number(limits, name) == (uint64_t)family)
425			return (true);
426	}
427
428	/* If there are no families at all, allow any family. */
429	if (nofamilies)
430		return (true);
431
432	return (false);
433}
434
435static void
436hostent_pack(const struct hostent *hp, nvlist_t *nvl)
437{
438	unsigned int ii;
439	char nvlname[64];
440	int n;
441
442	nvlist_add_string(nvl, "name", hp->h_name);
443	nvlist_add_number(nvl, "addrtype", (uint64_t)hp->h_addrtype);
444	nvlist_add_number(nvl, "length", (uint64_t)hp->h_length);
445
446	if (hp->h_aliases == NULL) {
447		nvlist_add_number(nvl, "naliases", 0);
448	} else {
449		for (ii = 0; hp->h_aliases[ii] != NULL; ii++) {
450			n = snprintf(nvlname, sizeof(nvlname), "alias%u", ii);
451			assert(n > 0 && n < (int)sizeof(nvlname));
452			nvlist_add_string(nvl, nvlname, hp->h_aliases[ii]);
453		}
454		nvlist_add_number(nvl, "naliases", (uint64_t)ii);
455	}
456
457	if (hp->h_addr_list == NULL) {
458		nvlist_add_number(nvl, "naddrs", 0);
459	} else {
460		for (ii = 0; hp->h_addr_list[ii] != NULL; ii++) {
461			n = snprintf(nvlname, sizeof(nvlname), "addr%u", ii);
462			assert(n > 0 && n < (int)sizeof(nvlname));
463			nvlist_add_binary(nvl, nvlname, hp->h_addr_list[ii],
464			    (size_t)hp->h_length);
465		}
466		nvlist_add_number(nvl, "naddrs", (uint64_t)ii);
467	}
468}
469
470static int
471dns_gethostbyname(const nvlist_t *limits, const nvlist_t *nvlin,
472    nvlist_t *nvlout)
473{
474	struct hostent *hp;
475	int family;
476
477	if (!dns_allowed_type(limits, "NAME2ADDR") &&
478	    !dns_allowed_type(limits, "NAME"))
479		return (NO_RECOVERY);
480
481	family = (int)nvlist_get_number(nvlin, "family");
482
483	if (!dns_allowed_family(limits, family))
484		return (NO_RECOVERY);
485
486	hp = gethostbyname2(nvlist_get_string(nvlin, "name"), family);
487	if (hp == NULL)
488		return (h_errno);
489	hostent_pack(hp, nvlout);
490	return (0);
491}
492
493static int
494dns_gethostbyaddr(const nvlist_t *limits, const nvlist_t *nvlin,
495    nvlist_t *nvlout)
496{
497	struct hostent *hp;
498	const void *addr;
499	size_t addrsize;
500	int family;
501
502	if (!dns_allowed_type(limits, "ADDR2NAME") &&
503	    !dns_allowed_type(limits, "ADDR"))
504		return (NO_RECOVERY);
505
506	family = (int)nvlist_get_number(nvlin, "family");
507
508	if (!dns_allowed_family(limits, family))
509		return (NO_RECOVERY);
510
511	addr = nvlist_get_binary(nvlin, "addr", &addrsize);
512	hp = gethostbyaddr(addr, (socklen_t)addrsize, family);
513	if (hp == NULL)
514		return (h_errno);
515	hostent_pack(hp, nvlout);
516	return (0);
517}
518
519static int
520dns_getnameinfo(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout)
521{
522	struct sockaddr_storage sast;
523	const void *sabin;
524	char *host, *serv;
525	size_t sabinsize, hostlen, servlen;
526	socklen_t salen;
527	int error, flags;
528
529	if (!dns_allowed_type(limits, "ADDR2NAME") &&
530	    !dns_allowed_type(limits, "ADDR"))
531		return (NO_RECOVERY);
532
533	error = 0;
534	host = serv = NULL;
535	memset(&sast, 0, sizeof(sast));
536
537	hostlen = (size_t)nvlist_get_number(nvlin, "hostlen");
538	servlen = (size_t)nvlist_get_number(nvlin, "servlen");
539
540	if (hostlen > 0) {
541		host = calloc(1, hostlen + 1);
542		if (host == NULL) {
543			error = EAI_MEMORY;
544			goto out;
545		}
546	}
547	if (servlen > 0) {
548		serv = calloc(1, servlen + 1);
549		if (serv == NULL) {
550			error = EAI_MEMORY;
551			goto out;
552		}
553	}
554
555	sabin = nvlist_get_binary(nvlin, "sa", &sabinsize);
556	if (sabinsize > sizeof(sast)) {
557		error = EAI_FAIL;
558		goto out;
559	}
560
561	memcpy(&sast, sabin, sabinsize);
562	salen = (socklen_t)sabinsize;
563
564	if ((sast.ss_family != AF_INET ||
565	     salen != sizeof(struct sockaddr_in)) &&
566	    (sast.ss_family != AF_INET6 ||
567	     salen != sizeof(struct sockaddr_in6))) {
568		error = EAI_FAIL;
569		goto out;
570	}
571
572	if (!dns_allowed_family(limits, (int)sast.ss_family)) {
573		error = NO_RECOVERY;
574		goto out;
575	}
576
577	flags = (int)nvlist_get_number(nvlin, "flags");
578
579	error = getnameinfo((struct sockaddr *)&sast, salen, host, hostlen,
580	    serv, servlen, flags);
581	if (error != 0)
582		goto out;
583
584	if (host != NULL)
585		nvlist_move_string(nvlout, "host", host);
586	if (serv != NULL)
587		nvlist_move_string(nvlout, "serv", serv);
588out:
589	if (error != 0) {
590		free(host);
591		free(serv);
592	}
593	return (error);
594}
595
596static nvlist_t *
597addrinfo_pack(const struct addrinfo *ai)
598{
599	nvlist_t *nvl;
600
601	nvl = nvlist_create(0);
602	nvlist_add_number(nvl, "ai_flags", (uint64_t)ai->ai_flags);
603	nvlist_add_number(nvl, "ai_family", (uint64_t)ai->ai_family);
604	nvlist_add_number(nvl, "ai_socktype", (uint64_t)ai->ai_socktype);
605	nvlist_add_number(nvl, "ai_protocol", (uint64_t)ai->ai_protocol);
606	nvlist_add_binary(nvl, "ai_addr", ai->ai_addr, (size_t)ai->ai_addrlen);
607	if (ai->ai_canonname != NULL)
608		nvlist_add_string(nvl, "ai_canonname", ai->ai_canonname);
609
610	return (nvl);
611}
612
613static int
614dns_getaddrinfo(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout)
615{
616	struct addrinfo hints, *hintsp, *res, *cur;
617	const char *hostname, *servname;
618	char nvlname[64];
619	nvlist_t *elem;
620	unsigned int ii;
621	int error, family, n;
622
623	if (!dns_allowed_type(limits, "NAME2ADDR") &&
624	    !dns_allowed_type(limits, "NAME"))
625		return (NO_RECOVERY);
626
627	hostname = dnvlist_get_string(nvlin, "hostname", NULL);
628	servname = dnvlist_get_string(nvlin, "servname", NULL);
629	if (nvlist_exists_number(nvlin, "hints.ai_flags")) {
630		hints.ai_flags = (int)nvlist_get_number(nvlin,
631		    "hints.ai_flags");
632		hints.ai_family = (int)nvlist_get_number(nvlin,
633		    "hints.ai_family");
634		hints.ai_socktype = (int)nvlist_get_number(nvlin,
635		    "hints.ai_socktype");
636		hints.ai_protocol = (int)nvlist_get_number(nvlin,
637		    "hints.ai_protocol");
638		hints.ai_addrlen = 0;
639		hints.ai_addr = NULL;
640		hints.ai_canonname = NULL;
641		hints.ai_next = NULL;
642		hintsp = &hints;
643		family = hints.ai_family;
644	} else {
645		hintsp = NULL;
646		family = AF_UNSPEC;
647	}
648
649	if (!dns_allowed_family(limits, family))
650		return (NO_RECOVERY);
651
652	error = getaddrinfo(hostname, servname, hintsp, &res);
653	if (error != 0)
654		goto out;
655
656	for (cur = res, ii = 0; cur != NULL; cur = cur->ai_next, ii++) {
657		elem = addrinfo_pack(cur);
658		n = snprintf(nvlname, sizeof(nvlname), "res%u", ii);
659		assert(n > 0 && n < (int)sizeof(nvlname));
660		nvlist_move_nvlist(nvlout, nvlname, elem);
661	}
662
663	freeaddrinfo(res);
664	error = 0;
665out:
666	return (error);
667}
668
669static bool
670limit_has_entry(const nvlist_t *limits, const char *prefix)
671{
672	const char *name;
673	size_t prefixlen;
674	void *cookie;
675
676	if (limits == NULL)
677		return (false);
678
679	prefixlen = strlen(prefix);
680
681	cookie = NULL;
682	while ((name = nvlist_next(limits, NULL, &cookie)) != NULL) {
683		if (strncmp(name, prefix, prefixlen) == 0)
684			return (true);
685	}
686
687	return (false);
688}
689
690static int
691dns_limit(const nvlist_t *oldlimits, const nvlist_t *newlimits)
692{
693	const char *name;
694	void *cookie;
695	int nvtype;
696	bool hastype, hasfamily;
697
698	hastype = false;
699	hasfamily = false;
700
701	cookie = NULL;
702	while ((name = nvlist_next(newlimits, &nvtype, &cookie)) != NULL) {
703		if (nvtype == NV_TYPE_STRING) {
704			const char *type;
705
706			if (strncmp(name, "type", sizeof("type") - 1) != 0)
707				return (EINVAL);
708			type = nvlist_get_string(newlimits, name);
709			if (strcmp(type, "ADDR2NAME") != 0 &&
710			    strcmp(type, "NAME2ADDR") != 0 &&
711			    strcmp(type, "ADDR") != 0 &&
712			    strcmp(type, "NAME") != 0) {
713				return (EINVAL);
714			}
715			if (!dns_allowed_type(oldlimits, type))
716				return (ENOTCAPABLE);
717			hastype = true;
718		} else if (nvtype == NV_TYPE_NUMBER) {
719			int family;
720
721			if (strncmp(name, "family", sizeof("family") - 1) != 0)
722				return (EINVAL);
723			family = (int)nvlist_get_number(newlimits, name);
724			if (!dns_allowed_family(oldlimits, family))
725				return (ENOTCAPABLE);
726			hasfamily = true;
727		} else {
728			return (EINVAL);
729		}
730	}
731
732	/*
733	 * If the new limit doesn't mention type or family we have to
734	 * check if the current limit does have those. Missing type or
735	 * family in the limit means that all types or families are
736	 * allowed.
737	 */
738	if (!hastype) {
739		if (limit_has_entry(oldlimits, "type"))
740			return (ENOTCAPABLE);
741	}
742	if (!hasfamily) {
743		if (limit_has_entry(oldlimits, "family"))
744			return (ENOTCAPABLE);
745	}
746
747	return (0);
748}
749
750static int
751dns_command(const char *cmd, const nvlist_t *limits, nvlist_t *nvlin,
752    nvlist_t *nvlout)
753{
754	int error;
755
756	if (strcmp(cmd, "gethostbyname") == 0)
757		error = dns_gethostbyname(limits, nvlin, nvlout);
758	else if (strcmp(cmd, "gethostbyaddr") == 0)
759		error = dns_gethostbyaddr(limits, nvlin, nvlout);
760	else if (strcmp(cmd, "getnameinfo") == 0)
761		error = dns_getnameinfo(limits, nvlin, nvlout);
762	else if (strcmp(cmd, "getaddrinfo") == 0)
763		error = dns_getaddrinfo(limits, nvlin, nvlout);
764	else
765		error = NO_RECOVERY;
766
767	return (error);
768}
769
770CREATE_SERVICE("system.dns", dns_limit, dns_command, 0);
771