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