1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009 James Gritton.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/jail.h>
34 #include <sys/linker.h>
35 #include <sys/socket.h>
36 #include <sys/sysctl.h>
37
38 #include <arpa/inet.h>
39 #include <netinet/in.h>
40
41 #include <errno.h>
42 #include <inttypes.h>
43 #include <stdio.h>
44 #include <stdarg.h>
45 #include <stdlib.h>
46 #include <string.h>
47
48 #include "jail.h"
49
50 #define SJPARAM "security.jail.param"
51
52 #define JPS_IN_ADDR 1
53 #define JPS_IN6_ADDR 2
54
55 #define ARRAY_SANITY 5
56 #define ARRAY_SLOP 5
57
58
59 static int jailparam_import_enum(const char **values, int nvalues,
60 const char *valstr, size_t valsize, int *value);
61 static int jailparam_type(struct jailparam *jp);
62 static int kldload_param(const char *name);
63 static char *noname(const char *name);
64 static char *nononame(const char *name);
65
66 char jail_errmsg[JAIL_ERRMSGLEN];
67
68 static const char *bool_values[] = { "false", "true" };
69 static const char *jailsys_values[] = { "disable", "new", "inherit" };
70
71
72 /*
73 * Import a null-terminated parameter list and set a jail with the flags
74 * and parameters.
75 */
76 int
jail_setv(int flags,...)77 jail_setv(int flags, ...)
78 {
79 va_list ap, tap;
80 struct jailparam *jp;
81 const char *name, *value;
82 int njp, jid;
83
84 /* Create the parameter list and import the parameters. */
85 va_start(ap, flags);
86 va_copy(tap, ap);
87 for (njp = 0; va_arg(tap, char *) != NULL; njp++)
88 (void)va_arg(tap, char *);
89 va_end(tap);
90 jp = alloca(njp * sizeof(struct jailparam));
91 for (njp = 0; (name = va_arg(ap, char *)) != NULL;) {
92 value = va_arg(ap, char *);
93 if (jailparam_init(jp + njp, name) < 0)
94 goto error;
95 if (jailparam_import(jp + njp++, value) < 0)
96 goto error;
97 }
98 va_end(ap);
99 jid = jailparam_set(jp, njp, flags);
100 jailparam_free(jp, njp);
101 return (jid);
102
103 error:
104 jailparam_free(jp, njp);
105 va_end(ap);
106 return (-1);
107 }
108
109 /*
110 * Read a null-terminated parameter list, get the referenced jail, and export
111 * the parameters to the list.
112 */
113 int
jail_getv(int flags,...)114 jail_getv(int flags, ...)
115 {
116 va_list ap, tap;
117 struct jailparam *jp, *jp_lastjid, *jp_jid, *jp_name, *jp_key;
118 char *valarg, *value;
119 const char *name, *key_value, *lastjid_value, *jid_value, *name_value;
120 int njp, i, jid;
121
122 /* Create the parameter list and find the key. */
123 va_start(ap, flags);
124 va_copy(tap, ap);
125 for (njp = 0; va_arg(tap, char *) != NULL; njp++)
126 (void)va_arg(tap, char *);
127 va_end(tap);
128
129 jp = alloca(njp * sizeof(struct jailparam));
130 va_copy(tap, ap);
131 jp_lastjid = jp_jid = jp_name = NULL;
132 lastjid_value = jid_value = name_value = NULL;
133 for (njp = 0; (name = va_arg(tap, char *)) != NULL; njp++) {
134 value = va_arg(tap, char *);
135 if (jailparam_init(jp + njp, name) < 0) {
136 va_end(tap);
137 goto error;
138 }
139 if (!strcmp(jp[njp].jp_name, "lastjid")) {
140 jp_lastjid = jp + njp;
141 lastjid_value = value;
142 } else if (!strcmp(jp[njp].jp_name, "jid")) {
143 jp_jid = jp + njp;
144 jid_value = value;
145 } if (!strcmp(jp[njp].jp_name, "name")) {
146 jp_name = jp + njp;
147 name_value = value;
148 }
149 }
150 va_end(tap);
151 /* Import the key parameter. */
152 if (jp_lastjid != NULL) {
153 jp_key = jp_lastjid;
154 key_value = lastjid_value;
155 } else if (jp_jid != NULL && strtol(jid_value, NULL, 10) != 0) {
156 jp_key = jp_jid;
157 key_value = jid_value;
158 } else if (jp_name != NULL) {
159 jp_key = jp_name;
160 key_value = name_value;
161 } else {
162 strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN);
163 errno = ENOENT;
164 goto error;
165 }
166 if (jailparam_import(jp_key, key_value) < 0)
167 goto error;
168 /* Get the jail and export the parameters. */
169 jid = jailparam_get(jp, njp, flags);
170 if (jid < 0)
171 goto error;
172 for (i = 0; i < njp; i++) {
173 (void)va_arg(ap, char *);
174 valarg = va_arg(ap, char *);
175 if (jp + i != jp_key) {
176 /* It's up to the caller to ensure there's room. */
177 if ((jp[i].jp_ctltype & CTLTYPE) == CTLTYPE_STRING)
178 strcpy(valarg, jp[i].jp_value);
179 else {
180 value = jailparam_export(jp + i);
181 if (value == NULL)
182 goto error;
183 strcpy(valarg, value);
184 free(value);
185 }
186 }
187 }
188 jailparam_free(jp, njp);
189 va_end(ap);
190 return (jid);
191
192 error:
193 jailparam_free(jp, njp);
194 va_end(ap);
195 return (-1);
196 }
197
198 /*
199 * Return a list of all known parameters.
200 */
201 int
jailparam_all(struct jailparam ** jpp)202 jailparam_all(struct jailparam **jpp)
203 {
204 struct jailparam *jp, *tjp;
205 size_t mlen1, mlen2, buflen;
206 unsigned njp, nlist;
207 int mib1[CTL_MAXNAME], mib2[CTL_MAXNAME - 2];
208 char buf[MAXPATHLEN];
209
210 njp = 0;
211 nlist = 32;
212 jp = malloc(nlist * sizeof(*jp));
213 if (jp == NULL) {
214 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
215 return (-1);
216 }
217 mib1[0] = 0;
218 mib1[1] = 2;
219 mlen1 = CTL_MAXNAME - 2;
220 if (sysctlnametomib(SJPARAM, mib1 + 2, &mlen1) < 0) {
221 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
222 "sysctlnametomib(" SJPARAM "): %s", strerror(errno));
223 goto error;
224 }
225 for (;; njp++) {
226 /* Get the next parameter. */
227 mlen2 = sizeof(mib2);
228 if (sysctl(mib1, mlen1 + 2, mib2, &mlen2, NULL, 0) < 0) {
229 if (errno == ENOENT) {
230 /* No more entries. */
231 break;
232 }
233 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
234 "sysctl(0.2): %s", strerror(errno));
235 goto error;
236 }
237 if (mib2[0] != mib1[2] ||
238 mib2[1] != mib1[3] ||
239 mib2[2] != mib1[4])
240 break;
241 /* Convert it to an ascii name. */
242 memcpy(mib1 + 2, mib2, mlen2);
243 mlen1 = mlen2 / sizeof(int);
244 mib1[1] = 1;
245 buflen = sizeof(buf);
246 if (sysctl(mib1, mlen1 + 2, buf, &buflen, NULL, 0) < 0) {
247 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
248 "sysctl(0.1): %s", strerror(errno));
249 goto error;
250 }
251 if (buf[buflen - 2] == '.')
252 buf[buflen - 2] = '\0';
253 /* Add the parameter to the list */
254 if (njp >= nlist) {
255 nlist *= 2;
256 tjp = reallocarray(jp, nlist, sizeof(*jp));
257 if (tjp == NULL)
258 goto error;
259 jp = tjp;
260 }
261 if (jailparam_init(jp + njp, buf + sizeof(SJPARAM)) < 0)
262 goto error;
263 mib1[1] = 2;
264 }
265 /* Just return the untrimmed buffer if reallocarray() somehow fails. */
266 tjp = reallocarray(jp, njp, sizeof(*jp));
267 if (tjp != NULL)
268 jp = tjp;
269 *jpp = jp;
270 return (njp);
271
272 error:
273 jailparam_free(jp, njp);
274 free(jp);
275 return (-1);
276 }
277
278 /*
279 * Clear a jail parameter and copy in its name.
280 */
281 int
jailparam_init(struct jailparam * jp,const char * name)282 jailparam_init(struct jailparam *jp, const char *name)
283 {
284
285 memset(jp, 0, sizeof(*jp));
286 jp->jp_name = strdup(name);
287 if (jp->jp_name == NULL) {
288 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
289 return (-1);
290 }
291 if (jailparam_type(jp) < 0) {
292 jailparam_free(jp, 1);
293 jp->jp_name = NULL;
294 jp->jp_value = NULL;
295 return (-1);
296 }
297 return (0);
298 }
299
300 /*
301 * Put a name and value into a jail parameter element, converting the value
302 * to internal form.
303 */
304 int
jailparam_import(struct jailparam * jp,const char * value)305 jailparam_import(struct jailparam *jp, const char *value)
306 {
307 char *p, *ep, *tvalue;
308 const char *avalue;
309 int i, nval, fw;
310
311 if (value == NULL)
312 return (0);
313 if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
314 jp->jp_value = strdup(value);
315 if (jp->jp_value == NULL) {
316 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
317 return (-1);
318 }
319 return (0);
320 }
321 nval = 1;
322 if (jp->jp_elemlen) {
323 if (value[0] == '\0' || (value[0] == '-' && value[1] == '\0')) {
324 jp->jp_value = strdup("");
325 if (jp->jp_value == NULL) {
326 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
327 return (-1);
328 }
329 jp->jp_valuelen = 0;
330 return (0);
331 }
332 for (p = strchr(value, ','); p; p = strchr(p + 1, ','))
333 nval++;
334 jp->jp_valuelen = jp->jp_elemlen * nval;
335 }
336 jp->jp_value = malloc(jp->jp_valuelen);
337 if (jp->jp_value == NULL) {
338 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
339 return (-1);
340 }
341 avalue = value;
342 for (i = 0; i < nval; i++) {
343 fw = nval == 1 ? strlen(avalue) : strcspn(avalue, ",");
344 switch (jp->jp_ctltype & CTLTYPE) {
345 case CTLTYPE_INT:
346 if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) {
347 if (!jailparam_import_enum(bool_values, 2,
348 avalue, fw, &((int *)jp->jp_value)[i])) {
349 snprintf(jail_errmsg,
350 JAIL_ERRMSGLEN, "%s: "
351 "unknown boolean value \"%.*s\"",
352 jp->jp_name, fw, avalue);
353 errno = EINVAL;
354 goto error;
355 }
356 break;
357 }
358 if (jp->jp_flags & JP_JAILSYS) {
359 /*
360 * Allow setting a jailsys parameter to "new"
361 * in a booleanesque fashion.
362 */
363 if (value[0] == '\0')
364 ((int *)jp->jp_value)[i] = JAIL_SYS_NEW;
365 else if (!jailparam_import_enum(jailsys_values,
366 sizeof(jailsys_values) /
367 sizeof(jailsys_values[0]), avalue, fw,
368 &((int *)jp->jp_value)[i])) {
369 snprintf(jail_errmsg,
370 JAIL_ERRMSGLEN, "%s: "
371 "unknown jailsys value \"%.*s\"",
372 jp->jp_name, fw, avalue);
373 errno = EINVAL;
374 goto error;
375 }
376 break;
377 }
378 ((int *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
379 integer_test:
380 if (ep != avalue + fw) {
381 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
382 "%s: non-integer value \"%.*s\"",
383 jp->jp_name, fw, avalue);
384 errno = EINVAL;
385 goto error;
386 }
387 break;
388 case CTLTYPE_UINT:
389 ((unsigned *)jp->jp_value)[i] =
390 strtoul(avalue, &ep, 10);
391 goto integer_test;
392 case CTLTYPE_LONG:
393 ((long *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
394 goto integer_test;
395 case CTLTYPE_ULONG:
396 ((unsigned long *)jp->jp_value)[i] =
397 strtoul(avalue, &ep, 10);
398 goto integer_test;
399 case CTLTYPE_S64:
400 ((int64_t *)jp->jp_value)[i] =
401 strtoimax(avalue, &ep, 10);
402 goto integer_test;
403 case CTLTYPE_U64:
404 ((uint64_t *)jp->jp_value)[i] =
405 strtoumax(avalue, &ep, 10);
406 goto integer_test;
407 case CTLTYPE_STRUCT:
408 tvalue = alloca(fw + 1);
409 strlcpy(tvalue, avalue, fw + 1);
410 switch (jp->jp_structtype) {
411 case JPS_IN_ADDR:
412 if (inet_pton(AF_INET, tvalue,
413 &((struct in_addr *)jp->jp_value)[i]) != 1)
414 {
415 snprintf(jail_errmsg,
416 JAIL_ERRMSGLEN,
417 "%s: not an IPv4 address: %s",
418 jp->jp_name, tvalue);
419 errno = EINVAL;
420 goto error;
421 }
422 break;
423 case JPS_IN6_ADDR:
424 if (inet_pton(AF_INET6, tvalue,
425 &((struct in6_addr *)jp->jp_value)[i]) != 1)
426 {
427 snprintf(jail_errmsg,
428 JAIL_ERRMSGLEN,
429 "%s: not an IPv6 address: %s",
430 jp->jp_name, tvalue);
431 errno = EINVAL;
432 goto error;
433 }
434 break;
435 default:
436 goto unknown_type;
437 }
438 break;
439 default:
440 unknown_type:
441 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
442 "unknown type for %s", jp->jp_name);
443 errno = ENOENT;
444 goto error;
445 }
446 avalue += fw + 1;
447 }
448 return (0);
449
450 error:
451 free(jp->jp_value);
452 jp->jp_value = NULL;
453 return (-1);
454 }
455
456 static int
jailparam_import_enum(const char ** values,int nvalues,const char * valstr,size_t valsize,int * value)457 jailparam_import_enum(const char **values, int nvalues, const char *valstr,
458 size_t valsize, int *value)
459 {
460 char *ep;
461 int i;
462
463 for (i = 0; i < nvalues; i++)
464 if (valsize == strlen(values[i]) &&
465 !strncasecmp(valstr, values[i], valsize)) {
466 *value = i;
467 return 1;
468 }
469 *value = strtol(valstr, &ep, 10);
470 return (ep == valstr + valsize);
471 }
472
473 /*
474 * Put a name and value into a jail parameter element, copying the value
475 * but not altering it.
476 */
477 int
jailparam_import_raw(struct jailparam * jp,void * value,size_t valuelen)478 jailparam_import_raw(struct jailparam *jp, void *value, size_t valuelen)
479 {
480
481 jp->jp_value = value;
482 jp->jp_valuelen = valuelen;
483 jp->jp_flags |= JP_RAWVALUE;
484 return (0);
485 }
486
487 /*
488 * Run the jail_set and jail_get system calls on a parameter list.
489 */
490 int
jailparam_set(struct jailparam * jp,unsigned njp,int flags)491 jailparam_set(struct jailparam *jp, unsigned njp, int flags)
492 {
493 struct iovec *jiov;
494 char *nname;
495 int i, jid, bool0;
496 unsigned j;
497
498 jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1));
499 bool0 = 0;
500 for (i = j = 0; j < njp; j++) {
501 jiov[i].iov_base = jp[j].jp_name;
502 jiov[i].iov_len = strlen(jp[j].jp_name) + 1;
503 i++;
504 if (jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) {
505 /*
506 * Set booleans without values. If one has a value of
507 * zero, change it to (or from) its "no" counterpart.
508 */
509 jiov[i].iov_base = NULL;
510 jiov[i].iov_len = 0;
511 if (jp[j].jp_value != NULL &&
512 jp[j].jp_valuelen == sizeof(int) &&
513 !*(int *)jp[j].jp_value) {
514 bool0 = 1;
515 nname = jp[j].jp_flags & JP_BOOL
516 ? noname(jp[j].jp_name)
517 : nononame(jp[j].jp_name);
518 if (nname == NULL) {
519 njp = j;
520 jid = -1;
521 goto done;
522 }
523 jiov[i - 1].iov_base = nname;
524 jiov[i - 1].iov_len = strlen(nname) + 1;
525
526 }
527 } else {
528 /*
529 * Try to fill in missing values with an empty string.
530 */
531 if (jp[j].jp_value == NULL && jp[j].jp_valuelen > 0 &&
532 jailparam_import(jp + j, "") < 0) {
533 njp = j;
534 jid = -1;
535 goto done;
536 }
537 jiov[i].iov_base = jp[j].jp_value;
538 jiov[i].iov_len =
539 (jp[j].jp_ctltype & CTLTYPE) == CTLTYPE_STRING
540 ? strlen(jp[j].jp_value) + 1
541 : jp[j].jp_valuelen;
542 }
543 i++;
544 }
545 jiov[i].iov_base = __DECONST(char *, "errmsg");
546 jiov[i].iov_len = sizeof("errmsg");
547 i++;
548 jiov[i].iov_base = jail_errmsg;
549 jiov[i].iov_len = JAIL_ERRMSGLEN;
550 i++;
551 jail_errmsg[0] = 0;
552 jid = jail_set(jiov, i, flags);
553 if (jid < 0 && !jail_errmsg[0])
554 snprintf(jail_errmsg, sizeof(jail_errmsg), "jail_set: %s",
555 strerror(errno));
556 done:
557 if (bool0)
558 for (j = 0; j < njp; j++)
559 if ((jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) &&
560 jp[j].jp_value != NULL &&
561 jp[j].jp_valuelen == sizeof(int) &&
562 !*(int *)jp[j].jp_value)
563 free(jiov[j * 2].iov_base);
564 return (jid);
565 }
566
567 int
jailparam_get(struct jailparam * jp,unsigned njp,int flags)568 jailparam_get(struct jailparam *jp, unsigned njp, int flags)
569 {
570 struct iovec *jiov;
571 struct jailparam *jp_lastjid, *jp_jid, *jp_name, *jp_key;
572 int i, ai, ki, jid, arrays, sanity;
573 unsigned j;
574
575 /*
576 * Get the types for all parameters.
577 * Find the key and any array parameters.
578 */
579 jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1));
580 jp_lastjid = jp_jid = jp_name = NULL;
581 arrays = 0;
582 for (ai = j = 0; j < njp; j++) {
583 if (!strcmp(jp[j].jp_name, "lastjid"))
584 jp_lastjid = jp + j;
585 else if (!strcmp(jp[j].jp_name, "jid"))
586 jp_jid = jp + j;
587 else if (!strcmp(jp[j].jp_name, "name"))
588 jp_name = jp + j;
589 else if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
590 arrays = 1;
591 jiov[ai].iov_base = jp[j].jp_name;
592 jiov[ai].iov_len = strlen(jp[j].jp_name) + 1;
593 ai++;
594 jiov[ai].iov_base = NULL;
595 jiov[ai].iov_len = 0;
596 ai++;
597 }
598 }
599 jp_key = jp_lastjid ? jp_lastjid :
600 jp_jid && jp_jid->jp_valuelen == sizeof(int) &&
601 jp_jid->jp_value && *(int *)jp_jid->jp_value ? jp_jid : jp_name;
602 if (jp_key == NULL || jp_key->jp_value == NULL) {
603 strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN);
604 errno = ENOENT;
605 return (-1);
606 }
607 ki = ai;
608 jiov[ki].iov_base = jp_key->jp_name;
609 jiov[ki].iov_len = strlen(jp_key->jp_name) + 1;
610 ki++;
611 jiov[ki].iov_base = jp_key->jp_value;
612 jiov[ki].iov_len = (jp_key->jp_ctltype & CTLTYPE) == CTLTYPE_STRING
613 ? strlen(jp_key->jp_value) + 1 : jp_key->jp_valuelen;
614 ki++;
615 jiov[ki].iov_base = __DECONST(char *, "errmsg");
616 jiov[ki].iov_len = sizeof("errmsg");
617 ki++;
618 jiov[ki].iov_base = jail_errmsg;
619 jiov[ki].iov_len = JAIL_ERRMSGLEN;
620 ki++;
621 jail_errmsg[0] = 0;
622 if (arrays && jail_get(jiov, ki, flags) < 0) {
623 if (!jail_errmsg[0])
624 snprintf(jail_errmsg, sizeof(jail_errmsg),
625 "jail_get: %s", strerror(errno));
626 return (-1);
627 }
628 /* Allocate storage for all parameters. */
629 for (ai = j = 0, i = ki; j < njp; j++) {
630 if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
631 ai++;
632 jiov[ai].iov_len += jp[j].jp_elemlen * ARRAY_SLOP;
633 if (jp[j].jp_valuelen >= jiov[ai].iov_len)
634 jiov[ai].iov_len = jp[j].jp_valuelen;
635 else {
636 jp[j].jp_valuelen = jiov[ai].iov_len;
637 if (jp[j].jp_value != NULL)
638 free(jp[j].jp_value);
639 jp[j].jp_value = malloc(jp[j].jp_valuelen);
640 if (jp[j].jp_value == NULL) {
641 strerror_r(errno, jail_errmsg,
642 JAIL_ERRMSGLEN);
643 return (-1);
644 }
645 }
646 jiov[ai].iov_base = jp[j].jp_value;
647 memset(jiov[ai].iov_base, 0, jiov[ai].iov_len);
648 ai++;
649 } else if (jp + j != jp_key) {
650 jiov[i].iov_base = jp[j].jp_name;
651 jiov[i].iov_len = strlen(jp[j].jp_name) + 1;
652 i++;
653 if (jp[j].jp_value == NULL &&
654 !(jp[j].jp_flags & JP_RAWVALUE)) {
655 jp[j].jp_value = malloc(jp[j].jp_valuelen);
656 if (jp[j].jp_value == NULL) {
657 strerror_r(errno, jail_errmsg,
658 JAIL_ERRMSGLEN);
659 return (-1);
660 }
661 }
662 jiov[i].iov_base = jp[j].jp_value;
663 jiov[i].iov_len = jp[j].jp_valuelen;
664 memset(jiov[i].iov_base, 0, jiov[i].iov_len);
665 i++;
666 }
667 }
668 /*
669 * Get the prison. If there are array elements, retry a few times
670 * in case their sizes changed from under us.
671 */
672 for (sanity = 0;; sanity++) {
673 jid = jail_get(jiov, i, flags);
674 if (jid >= 0 || !arrays || sanity == ARRAY_SANITY ||
675 errno != EINVAL || jail_errmsg[0])
676 break;
677 for (ai = j = 0; j < njp; j++) {
678 if (jp[j].jp_elemlen &&
679 !(jp[j].jp_flags & JP_RAWVALUE)) {
680 ai++;
681 jiov[ai].iov_base = NULL;
682 jiov[ai].iov_len = 0;
683 ai++;
684 }
685 }
686 if (jail_get(jiov, ki, flags) < 0)
687 break;
688 for (ai = j = 0; j < njp; j++) {
689 if (jp[j].jp_elemlen &&
690 !(jp[j].jp_flags & JP_RAWVALUE)) {
691 ai++;
692 jiov[ai].iov_len +=
693 jp[j].jp_elemlen * ARRAY_SLOP;
694 if (jp[j].jp_valuelen >= jiov[ai].iov_len)
695 jiov[ai].iov_len = jp[j].jp_valuelen;
696 else {
697 jp[j].jp_valuelen = jiov[ai].iov_len;
698 if (jp[j].jp_value != NULL)
699 free(jp[j].jp_value);
700 jp[j].jp_value =
701 malloc(jiov[ai].iov_len);
702 if (jp[j].jp_value == NULL) {
703 strerror_r(errno, jail_errmsg,
704 JAIL_ERRMSGLEN);
705 return (-1);
706 }
707 }
708 jiov[ai].iov_base = jp[j].jp_value;
709 memset(jiov[ai].iov_base, 0, jiov[ai].iov_len);
710 ai++;
711 }
712 }
713 }
714 if (jid < 0 && !jail_errmsg[0])
715 snprintf(jail_errmsg, sizeof(jail_errmsg),
716 "jail_get: %s", strerror(errno));
717 for (ai = j = 0, i = ki; j < njp; j++) {
718 if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
719 ai++;
720 jp[j].jp_valuelen = jiov[ai].iov_len;
721 ai++;
722 } else if (jp + j != jp_key) {
723 i++;
724 jp[j].jp_valuelen = jiov[i].iov_len;
725 i++;
726 }
727 }
728 return (jid);
729 }
730
731 /*
732 * Convert a jail parameter's value to external form.
733 */
734 char *
jailparam_export(struct jailparam * jp)735 jailparam_export(struct jailparam *jp)
736 {
737 size_t *valuelens;
738 char *value, *tvalue, **values;
739 size_t valuelen;
740 int i, nval, ival;
741 char valbuf[INET6_ADDRSTRLEN];
742
743 if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
744 value = strdup(jp->jp_value);
745 if (value == NULL)
746 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
747 return (value);
748 }
749 nval = jp->jp_elemlen ? jp->jp_valuelen / jp->jp_elemlen : 1;
750 if (nval == 0) {
751 value = strdup("");
752 if (value == NULL)
753 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
754 return (value);
755 }
756 values = alloca(nval * sizeof(char *));
757 valuelens = alloca(nval * sizeof(size_t));
758 valuelen = 0;
759 for (i = 0; i < nval; i++) {
760 switch (jp->jp_ctltype & CTLTYPE) {
761 case CTLTYPE_INT:
762 ival = ((int *)jp->jp_value)[i];
763 if ((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) &&
764 (unsigned)ival < 2) {
765 strlcpy(valbuf, bool_values[ival],
766 sizeof(valbuf));
767 break;
768 }
769 if ((jp->jp_flags & JP_JAILSYS) &&
770 (unsigned)ival < sizeof(jailsys_values) /
771 sizeof(jailsys_values[0])) {
772 strlcpy(valbuf, jailsys_values[ival],
773 sizeof(valbuf));
774 break;
775 }
776 snprintf(valbuf, sizeof(valbuf), "%d", ival);
777 break;
778 case CTLTYPE_UINT:
779 snprintf(valbuf, sizeof(valbuf), "%u",
780 ((unsigned *)jp->jp_value)[i]);
781 break;
782 case CTLTYPE_LONG:
783 snprintf(valbuf, sizeof(valbuf), "%ld",
784 ((long *)jp->jp_value)[i]);
785 break;
786 case CTLTYPE_ULONG:
787 snprintf(valbuf, sizeof(valbuf), "%lu",
788 ((unsigned long *)jp->jp_value)[i]);
789 break;
790 case CTLTYPE_S64:
791 snprintf(valbuf, sizeof(valbuf), "%jd",
792 (intmax_t)((int64_t *)jp->jp_value)[i]);
793 break;
794 case CTLTYPE_U64:
795 snprintf(valbuf, sizeof(valbuf), "%ju",
796 (uintmax_t)((uint64_t *)jp->jp_value)[i]);
797 break;
798 case CTLTYPE_STRUCT:
799 switch (jp->jp_structtype) {
800 case JPS_IN_ADDR:
801 if (inet_ntop(AF_INET,
802 &((struct in_addr *)jp->jp_value)[i],
803 valbuf, sizeof(valbuf)) == NULL) {
804 strerror_r(errno, jail_errmsg,
805 JAIL_ERRMSGLEN);
806 return (NULL);
807 }
808 break;
809 case JPS_IN6_ADDR:
810 if (inet_ntop(AF_INET6,
811 &((struct in6_addr *)jp->jp_value)[i],
812 valbuf, sizeof(valbuf)) == NULL) {
813 strerror_r(errno, jail_errmsg,
814 JAIL_ERRMSGLEN);
815 return (NULL);
816 }
817 break;
818 default:
819 goto unknown_type;
820 }
821 break;
822 default:
823 unknown_type:
824 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
825 "unknown type for %s", jp->jp_name);
826 errno = ENOENT;
827 return (NULL);
828 }
829 valuelens[i] = strlen(valbuf) + 1;
830 valuelen += valuelens[i];
831 values[i] = alloca(valuelens[i]);
832 strcpy(values[i], valbuf);
833 }
834 value = malloc(valuelen);
835 if (value == NULL)
836 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
837 else {
838 tvalue = value;
839 for (i = 0; i < nval; i++) {
840 strcpy(tvalue, values[i]);
841 if (i < nval - 1) {
842 tvalue += valuelens[i];
843 tvalue[-1] = ',';
844 }
845 }
846 }
847 return (value);
848 }
849
850 /*
851 * Free the contents of a jail parameter list (but not the list itself).
852 */
853 void
jailparam_free(struct jailparam * jp,unsigned njp)854 jailparam_free(struct jailparam *jp, unsigned njp)
855 {
856 unsigned j;
857
858 for (j = 0; j < njp; j++) {
859 free(jp[j].jp_name);
860 if (!(jp[j].jp_flags & JP_RAWVALUE))
861 free(jp[j].jp_value);
862 }
863 }
864
865 /*
866 * Find a parameter's type and size from its MIB.
867 */
868 static int
jailparam_type(struct jailparam * jp)869 jailparam_type(struct jailparam *jp)
870 {
871 char *p, *name, *nname;
872 size_t miblen, desclen;
873 int i, isarray;
874 struct {
875 int i;
876 char s[MAXPATHLEN];
877 } desc;
878 int mib[CTL_MAXNAME];
879
880 /* The "lastjid" parameter isn't real. */
881 name = jp->jp_name;
882 if (!strcmp(name, "lastjid")) {
883 jp->jp_valuelen = sizeof(int);
884 jp->jp_ctltype = CTLTYPE_INT | CTLFLAG_WR;
885 return (0);
886 }
887
888 /* Find the sysctl that describes the parameter. */
889 mib[0] = 0;
890 mib[1] = 3;
891 snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", name);
892 miblen = sizeof(mib) - 2 * sizeof(int);
893 if (sysctl(mib, 2, mib + 2, &miblen, desc.s, strlen(desc.s)) < 0) {
894 if (errno != ENOENT) {
895 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
896 "sysctl(0.3.%s): %s", name, strerror(errno));
897 return (-1);
898 }
899 if (kldload_param(name) >= 0 && sysctl(mib, 2, mib + 2, &miblen,
900 desc.s, strlen(desc.s)) >= 0)
901 goto mib_desc;
902 /*
903 * The parameter probably doesn't exist. But it might be
904 * the "no" counterpart to a boolean.
905 */
906 nname = nononame(name);
907 if (nname == NULL) {
908 unknown_parameter:
909 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
910 "unknown parameter: %s", jp->jp_name);
911 errno = ENOENT;
912 return (-1);
913 }
914 name = alloca(strlen(nname) + 1);
915 strcpy(name, nname);
916 free(nname);
917 snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", name);
918 miblen = sizeof(mib) - 2 * sizeof(int);
919 if (sysctl(mib, 2, mib + 2, &miblen, desc.s,
920 strlen(desc.s)) < 0)
921 goto unknown_parameter;
922 jp->jp_flags |= JP_NOBOOL;
923 }
924 mib_desc:
925 mib[1] = 4;
926 desclen = sizeof(desc);
927 if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen,
928 NULL, 0) < 0) {
929 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
930 "sysctl(0.4.%s): %s", name, strerror(errno));
931 return (-1);
932 }
933 jp->jp_ctltype = desc.i;
934 /* If this came from removing a "no", it better be a boolean. */
935 if (jp->jp_flags & JP_NOBOOL) {
936 if ((desc.i & CTLTYPE) == CTLTYPE_INT && desc.s[0] == 'B') {
937 jp->jp_valuelen = sizeof(int);
938 return (0);
939 }
940 else if ((desc.i & CTLTYPE) != CTLTYPE_NODE)
941 goto unknown_parameter;
942 }
943 /* See if this is an array type. */
944 p = strchr(desc.s, '\0');
945 isarray = 0;
946 if (p - 2 < desc.s || strcmp(p - 2, ",a"))
947 isarray = 0;
948 else {
949 isarray = 1;
950 p[-2] = 0;
951 }
952 /* Look for types we understand. */
953 switch (desc.i & CTLTYPE) {
954 case CTLTYPE_INT:
955 if (desc.s[0] == 'B')
956 jp->jp_flags |= JP_BOOL;
957 else if (!strcmp(desc.s, "E,jailsys"))
958 jp->jp_flags |= JP_JAILSYS;
959 case CTLTYPE_UINT:
960 jp->jp_valuelen = sizeof(int);
961 break;
962 case CTLTYPE_LONG:
963 case CTLTYPE_ULONG:
964 jp->jp_valuelen = sizeof(long);
965 break;
966 case CTLTYPE_S64:
967 case CTLTYPE_U64:
968 jp->jp_valuelen = sizeof(int64_t);
969 break;
970 case CTLTYPE_STRING:
971 desc.s[0] = 0;
972 desclen = sizeof(desc.s);
973 if (sysctl(mib + 2, miblen / sizeof(int), desc.s, &desclen,
974 NULL, 0) < 0) {
975 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
976 "sysctl(" SJPARAM ".%s): %s", name,
977 strerror(errno));
978 return (-1);
979 }
980 jp->jp_valuelen = strtoul(desc.s, NULL, 10);
981 break;
982 case CTLTYPE_STRUCT:
983 if (!strcmp(desc.s, "S,in_addr")) {
984 jp->jp_structtype = JPS_IN_ADDR;
985 jp->jp_valuelen = sizeof(struct in_addr);
986 } else if (!strcmp(desc.s, "S,in6_addr")) {
987 jp->jp_structtype = JPS_IN6_ADDR;
988 jp->jp_valuelen = sizeof(struct in6_addr);
989 } else {
990 desclen = 0;
991 if (sysctl(mib + 2, miblen / sizeof(int),
992 NULL, &jp->jp_valuelen, NULL, 0) < 0) {
993 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
994 "sysctl(" SJPARAM ".%s): %s", name,
995 strerror(errno));
996 return (-1);
997 }
998 }
999 break;
1000 case CTLTYPE_NODE:
1001 /*
1002 * A node might be described by an empty-named child,
1003 * which would be immediately before or after the node itself.
1004 */
1005 mib[1] = 1;
1006 miblen += sizeof(int);
1007 for (i = -1; i <= 1; i += 2) {
1008 mib[(miblen / sizeof(int)) + 1] =
1009 mib[(miblen / sizeof(int))] + i;
1010 desclen = sizeof(desc.s);
1011 if (sysctl(mib, (miblen / sizeof(int)) + 2, desc.s,
1012 &desclen, NULL, 0) < 0) {
1013 if (errno == ENOENT)
1014 continue;
1015 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
1016 "sysctl(0.1): %s", strerror(errno));
1017 return (-1);
1018 }
1019 if (desclen == sizeof(SJPARAM) + strlen(name) + 2 &&
1020 memcmp(SJPARAM ".", desc.s, sizeof(SJPARAM)) == 0 &&
1021 memcmp(name, desc.s + sizeof(SJPARAM),
1022 desclen - sizeof(SJPARAM) - 2) == 0 &&
1023 desc.s[desclen - 2] == '.')
1024 goto mib_desc;
1025 }
1026 goto unknown_parameter;
1027 default:
1028 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
1029 "unknown type for %s", jp->jp_name);
1030 errno = ENOENT;
1031 return (-1);
1032 }
1033 if (isarray) {
1034 jp->jp_elemlen = jp->jp_valuelen;
1035 jp->jp_valuelen = 0;
1036 }
1037 return (0);
1038 }
1039
1040 /*
1041 * Attempt to load a kernel module matching an otherwise nonexistent parameter.
1042 */
1043 static int
kldload_param(const char * name)1044 kldload_param(const char *name)
1045 {
1046 int kl;
1047
1048 if (strcmp(name, "linux") == 0 || strncmp(name, "linux.", 6) == 0)
1049 kl = kldload("linux");
1050 else if (strcmp(name, "sysvmsg") == 0 || strcmp(name, "sysvsem") == 0 ||
1051 strcmp(name, "sysvshm") == 0)
1052 kl = kldload(name);
1053 else if (strncmp(name, "allow.mount.", 12) == 0) {
1054 /* Load the matching filesystem */
1055 const char *modname = name + 12;
1056
1057 kl = kldload(modname);
1058 if (kl < 0 && errno == ENOENT &&
1059 strncmp(modname, "no", 2) == 0)
1060 kl = kldload(modname + 2);
1061 } else {
1062 errno = ENOENT;
1063 return (-1);
1064 }
1065 if (kl < 0 && errno == EEXIST) {
1066 /*
1067 * In the module is already loaded, then it must not contain
1068 * the parameter.
1069 */
1070 errno = ENOENT;
1071 }
1072 return kl;
1073 }
1074
1075 /*
1076 * Change a boolean parameter name into its "no" counterpart or vice versa.
1077 */
1078 static char *
noname(const char * name)1079 noname(const char *name)
1080 {
1081 char *nname, *p;
1082
1083 nname = malloc(strlen(name) + 3);
1084 if (nname == NULL) {
1085 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
1086 return (NULL);
1087 }
1088 p = strrchr(name, '.');
1089 if (p != NULL)
1090 sprintf(nname, "%.*s.no%s", (int)(p - name), name, p + 1);
1091 else
1092 sprintf(nname, "no%s", name);
1093 return (nname);
1094 }
1095
1096 static char *
nononame(const char * name)1097 nononame(const char *name)
1098 {
1099 char *p, *nname;
1100
1101 p = strrchr(name, '.');
1102 if (strncmp(p ? p + 1 : name, "no", 2)) {
1103 snprintf(jail_errmsg, sizeof(jail_errmsg),
1104 "mismatched boolean: %s", name);
1105 errno = EINVAL;
1106 return (NULL);
1107 }
1108 nname = malloc(strlen(name) - 1);
1109 if (nname == NULL) {
1110 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
1111 return (NULL);
1112 }
1113 if (p != NULL)
1114 sprintf(nname, "%.*s.%s", (int)(p - name), name, p + 3);
1115 else
1116 strcpy(nname, name + 2);
1117 return (nname);
1118 }
1119