Deleted Added
sdiff udiff text old ( 195011 ) new ( 195870 )
full compact
jail.c (195011) jail.c (195870)
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

--- 11 unchanged lines hidden (view full) ---

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>
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

--- 11 unchanged lines hidden (view full) ---

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: head/lib/libjail/jail.c 195011 2009-06-25 22:42:19Z jamie $");
28__FBSDID("$FreeBSD: head/lib/libjail/jail.c 195870 2009-07-25 14:48:57Z jamie $");
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>

--- 12 unchanged lines hidden (view full) ---

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
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>

--- 12 unchanged lines hidden (view full) ---

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
57static int jailparam_import_enum(const char **values, int nvalues,
58 const char *valstr, size_t valsize, int *value);
57static int jailparam_vlist(struct jailparam **jpp, va_list ap);
58static int jailparam_type(struct jailparam *jp);
59static char *noname(const char *name);
60static char *nononame(const char *name);
61
62char jail_errmsg[JAIL_ERRMSGLEN];
63
59static int jailparam_vlist(struct jailparam **jpp, va_list ap);
60static int jailparam_type(struct jailparam *jp);
61static char *noname(const char *name);
62static char *nononame(const char *name);
63
64char jail_errmsg[JAIL_ERRMSGLEN];
65
66static const char *bool_values[] = { "false", "true" };
67static const char *jailsys_values[] = { "disable", "new", "inherit" };
64
68
69
65/*
66 * Import a null-terminated parameter list and set a jail with the flags
67 * and parameters.
68 */
69int
70jail_setv(int flags, ...)
71{
72 va_list ap;

--- 62 unchanged lines hidden (view full) ---

135
136/*
137 * Return a list of all known parameters.
138 */
139int
140jailparam_all(struct jailparam **jpp)
141{
142 struct jailparam *jp;
70/*
71 * Import a null-terminated parameter list and set a jail with the flags
72 * and parameters.
73 */
74int
75jail_setv(int flags, ...)
76{
77 va_list ap;

--- 62 unchanged lines hidden (view full) ---

140
141/*
142 * Return a list of all known parameters.
143 */
144int
145jailparam_all(struct jailparam **jpp)
146{
147 struct jailparam *jp;
143 char *nname;
144 size_t mlen1, mlen2, buflen;
145 int njp, nlist;
146 int mib1[CTL_MAXNAME], mib2[CTL_MAXNAME - 2];
147 char buf[MAXPATHLEN];
148
149 njp = 0;
150 nlist = 32;
151 jp = malloc(nlist * sizeof(*jp));

--- 25 unchanged lines hidden (view full) ---

177 mlen1 = mlen2 / sizeof(int);
178 mib1[1] = 1;
179 buflen = sizeof(buf);
180 if (sysctl(mib1, mlen1 + 2, buf, &buflen, NULL, 0) < 0) {
181 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
182 "sysctl(0.1): %s", strerror(errno));
183 goto error;
184 }
148 size_t mlen1, mlen2, buflen;
149 int njp, nlist;
150 int mib1[CTL_MAXNAME], mib2[CTL_MAXNAME - 2];
151 char buf[MAXPATHLEN];
152
153 njp = 0;
154 nlist = 32;
155 jp = malloc(nlist * sizeof(*jp));

--- 25 unchanged lines hidden (view full) ---

181 mlen1 = mlen2 / sizeof(int);
182 mib1[1] = 1;
183 buflen = sizeof(buf);
184 if (sysctl(mib1, mlen1 + 2, buf, &buflen, NULL, 0) < 0) {
185 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
186 "sysctl(0.1): %s", strerror(errno));
187 goto error;
188 }
189 if (buf[buflen - 2] == '.')
190 buf[buflen - 2] = '\0';
185 /* Add the parameter to the list */
186 if (njp >= nlist) {
187 nlist *= 2;
188 jp = realloc(jp, nlist * sizeof(jp));
189 if (jp == NULL) {
190 jailparam_free(jp, njp);
191 return (-1);
192 }
193 }
194 if (jailparam_init(jp + njp, buf + sizeof(SJPARAM)) < 0)
195 goto error;
196 if (jailparam_type(jp + njp) < 0) {
197 njp++;
198 goto error;
199 }
191 /* Add the parameter to the list */
192 if (njp >= nlist) {
193 nlist *= 2;
194 jp = realloc(jp, nlist * sizeof(jp));
195 if (jp == NULL) {
196 jailparam_free(jp, njp);
197 return (-1);
198 }
199 }
200 if (jailparam_init(jp + njp, buf + sizeof(SJPARAM)) < 0)
201 goto error;
202 if (jailparam_type(jp + njp) < 0) {
203 njp++;
204 goto error;
205 }
200 /* Convert nobool parameters to bool. */
201 if (jp[njp].jp_flags & JP_NOBOOL) {
202 nname = nononame(jp[njp].jp_name);
203 if (nname == NULL) {
204 njp++;
205 goto error;
206 }
207 free(jp[njp].jp_name);
208 jp[njp].jp_name = nname;
209 jp[njp].jp_flags ^= JP_BOOL | JP_NOBOOL;
210 }
211 mib1[1] = 2;
212 }
213 jp = realloc(jp, njp * sizeof(*jp));
214 *jpp = jp;
215 return (njp);
216
217 error:
218 jailparam_free(jp, njp);

--- 61 unchanged lines hidden (view full) ---

280 return (-1);
281 }
282 avalue = value;
283 for (i = 0; i < nval; i++) {
284 fw = nval == 1 ? strlen(avalue) : strcspn(avalue, ",");
285 switch (jp->jp_ctltype & CTLTYPE) {
286 case CTLTYPE_INT:
287 if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) {
206 mib1[1] = 2;
207 }
208 jp = realloc(jp, njp * sizeof(*jp));
209 *jpp = jp;
210 return (njp);
211
212 error:
213 jailparam_free(jp, njp);

--- 61 unchanged lines hidden (view full) ---

275 return (-1);
276 }
277 avalue = value;
278 for (i = 0; i < nval; i++) {
279 fw = nval == 1 ? strlen(avalue) : strcspn(avalue, ",");
280 switch (jp->jp_ctltype & CTLTYPE) {
281 case CTLTYPE_INT:
282 if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) {
288 if (!strncasecmp(avalue, "true", 4))
289 ((int *)jp->jp_value)[i] = 1;
290 else if (!strncasecmp(avalue, "false", 5))
291 ((int *)jp->jp_value)[i] = 0;
292 else {
283 if (!jailparam_import_enum(bool_values, 2,
284 avalue, fw, &((int *)jp->jp_value)[i])) {
293 snprintf(jail_errmsg,
285 snprintf(jail_errmsg,
294 JAIL_ERRMSGLEN,
295 "%s: unknown boolean value \"%.*s\"",
286 JAIL_ERRMSGLEN, "%s: "
287 "unknown boolean value \"%.*s\"",
296 jp->jp_name, fw, avalue);
297 errno = EINVAL;
298 goto error;
299 }
300 break;
301 }
288 jp->jp_name, fw, avalue);
289 errno = EINVAL;
290 goto error;
291 }
292 break;
293 }
294 if (jp->jp_flags & JP_JAILSYS) {
295 /*
296 * Allow setting a jailsys parameter to "new"
297 * in a booleanesque fashion.
298 */
299 if (value[0] == '\0')
300 ((int *)jp->jp_value)[i] = JAIL_SYS_NEW;
301 else if (!jailparam_import_enum(jailsys_values,
302 sizeof(jailsys_values) /
303 sizeof(jailsys_values[0]), avalue, fw,
304 &((int *)jp->jp_value)[i])) {
305 snprintf(jail_errmsg,
306 JAIL_ERRMSGLEN, "%s: "
307 "unknown jailsys value \"%.*s\"",
308 jp->jp_name, fw, avalue);
309 errno = EINVAL;
310 goto error;
311 }
312 break;
313 }
302 ((int *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
303 integer_test:
304 if (ep != avalue + fw) {
305 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
306 "%s: non-integer value \"%.*s\"",
307 jp->jp_name, fw, avalue);
308 errno = EINVAL;
309 goto error;

--- 58 unchanged lines hidden (view full) ---

368 return (0);
369
370 error:
371 free(jp->jp_value);
372 jp->jp_value = NULL;
373 return (-1);
374}
375
314 ((int *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
315 integer_test:
316 if (ep != avalue + fw) {
317 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
318 "%s: non-integer value \"%.*s\"",
319 jp->jp_name, fw, avalue);
320 errno = EINVAL;
321 goto error;

--- 58 unchanged lines hidden (view full) ---

380 return (0);
381
382 error:
383 free(jp->jp_value);
384 jp->jp_value = NULL;
385 return (-1);
386}
387
388static int
389jailparam_import_enum(const char **values, int nvalues, const char *valstr,
390 size_t valsize, int *value)
391{
392 char *ep;
393 int i;
394
395 for (i = 0; i < nvalues; i++)
396 if (valsize == strlen(values[i]) &&
397 !strncasecmp(valstr, values[i], valsize)) {
398 *value = i;
399 return 1;
400 }
401 *value = strtol(valstr, &ep, 10);
402 return (ep == valstr + valsize);
403}
404
376/*
377 * Put a name and value into a jail parameter element, copying the value
378 * but not altering it.
379 */
380int
381jailparam_import_raw(struct jailparam *jp, void *value, size_t valuelen)
382{
383

--- 39 unchanged lines hidden (view full) ---

423 jid = -1;
424 goto done;
425 }
426 jiov[i - 1].iov_base = nname;
427 jiov[i - 1].iov_len = strlen(nname) + 1;
428
429 }
430 } else {
405/*
406 * Put a name and value into a jail parameter element, copying the value
407 * but not altering it.
408 */
409int
410jailparam_import_raw(struct jailparam *jp, void *value, size_t valuelen)
411{
412

--- 39 unchanged lines hidden (view full) ---

452 jid = -1;
453 goto done;
454 }
455 jiov[i - 1].iov_base = nname;
456 jiov[i - 1].iov_len = strlen(nname) + 1;
457
458 }
459 } else {
460 /*
461 * Try to fill in missing values with an empty string.
462 */
463 if (jp[j].jp_value == NULL && jp[j].jp_valuelen > 0 &&
464 jailparam_import(jp + j, "") < 0) {
465 njp = j;
466 jid = -1;
467 goto done;
468 }
431 jiov[i].iov_base = jp[j].jp_value;
432 jiov[i].iov_len =
433 (jp[j].jp_ctltype & CTLTYPE) == CTLTYPE_STRING
434 ? strlen(jp[j].jp_value) + 1
435 : jp[j].jp_valuelen;
436 }
437 i++;
438 }

--- 188 unchanged lines hidden (view full) ---

627/*
628 * Convert a jail parameter's value to external form.
629 */
630char *
631jailparam_export(struct jailparam *jp)
632{
633 char *value, *tvalue, **values;
634 size_t valuelen;
469 jiov[i].iov_base = jp[j].jp_value;
470 jiov[i].iov_len =
471 (jp[j].jp_ctltype & CTLTYPE) == CTLTYPE_STRING
472 ? strlen(jp[j].jp_value) + 1
473 : jp[j].jp_valuelen;
474 }
475 i++;
476 }

--- 188 unchanged lines hidden (view full) ---

665/*
666 * Convert a jail parameter's value to external form.
667 */
668char *
669jailparam_export(struct jailparam *jp)
670{
671 char *value, *tvalue, **values;
672 size_t valuelen;
635 int i, nval;
673 int i, nval, ival;
636 char valbuf[INET6_ADDRSTRLEN];
637
638 if (!jp->jp_ctltype && jailparam_type(jp) < 0)
639 return (NULL);
640 if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
641 value = strdup(jp->jp_value);
642 if (value == NULL)
643 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);

--- 6 unchanged lines hidden (view full) ---

650 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
651 return (value);
652 }
653 values = alloca(nval * sizeof(char *));
654 valuelen = 0;
655 for (i = 0; i < nval; i++) {
656 switch (jp->jp_ctltype & CTLTYPE) {
657 case CTLTYPE_INT:
674 char valbuf[INET6_ADDRSTRLEN];
675
676 if (!jp->jp_ctltype && jailparam_type(jp) < 0)
677 return (NULL);
678 if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
679 value = strdup(jp->jp_value);
680 if (value == NULL)
681 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);

--- 6 unchanged lines hidden (view full) ---

688 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
689 return (value);
690 }
691 values = alloca(nval * sizeof(char *));
692 valuelen = 0;
693 for (i = 0; i < nval; i++) {
694 switch (jp->jp_ctltype & CTLTYPE) {
695 case CTLTYPE_INT:
658 if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) {
659 strlcpy(valbuf,
660 ((int *)jp->jp_value)[i] ? "true" : "false",
696 ival = ((int *)jp->jp_value)[i];
697 if ((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) &&
698 (unsigned)ival < 2) {
699 strlcpy(valbuf, bool_values[ival],
661 sizeof(valbuf));
662 break;
663 }
700 sizeof(valbuf));
701 break;
702 }
664 snprintf(valbuf, sizeof(valbuf), "%d",
665 ((int *)jp->jp_value)[i]);
703 if ((jp->jp_flags & JP_JAILSYS) &&
704 (unsigned)ival < sizeof(jailsys_values) /
705 sizeof(jailsys_values[0])) {
706 strlcpy(valbuf, jailsys_values[ival],
707 sizeof(valbuf));
708 break;
709 }
710 snprintf(valbuf, sizeof(valbuf), "%d", ival);
666 break;
667 case CTLTYPE_UINT:
668 snprintf(valbuf, sizeof(valbuf), "%u",
669 ((unsigned *)jp->jp_value)[i]);
670 break;
671 case CTLTYPE_LONG:
672 snprintf(valbuf, sizeof(valbuf), "%ld",
673 ((long *)jp->jp_value)[i]);

--- 9 unchanged lines hidden (view full) ---

683 case CTLTYPE_STRUCT:
684 switch (jp->jp_structtype) {
685 case JPS_IN_ADDR:
686 if (inet_ntop(AF_INET,
687 &((struct in_addr *)jp->jp_value)[i],
688 valbuf, sizeof(valbuf)) == NULL) {
689 strerror_r(errno, jail_errmsg,
690 JAIL_ERRMSGLEN);
711 break;
712 case CTLTYPE_UINT:
713 snprintf(valbuf, sizeof(valbuf), "%u",
714 ((unsigned *)jp->jp_value)[i]);
715 break;
716 case CTLTYPE_LONG:
717 snprintf(valbuf, sizeof(valbuf), "%ld",
718 ((long *)jp->jp_value)[i]);

--- 9 unchanged lines hidden (view full) ---

728 case CTLTYPE_STRUCT:
729 switch (jp->jp_structtype) {
730 case JPS_IN_ADDR:
731 if (inet_ntop(AF_INET,
732 &((struct in_addr *)jp->jp_value)[i],
733 valbuf, sizeof(valbuf)) == NULL) {
734 strerror_r(errno, jail_errmsg,
735 JAIL_ERRMSGLEN);
691
736
692 return (NULL);
693 }
694 break;
695 case JPS_IN6_ADDR:
696 if (inet_ntop(AF_INET6,
697 &((struct in6_addr *)jp->jp_value)[i],
698 valbuf, sizeof(valbuf)) == NULL) {
699 strerror_r(errno, jail_errmsg,
700 JAIL_ERRMSGLEN);
737 return (NULL);
738 }
739 break;
740 case JPS_IN6_ADDR:
741 if (inet_ntop(AF_INET6,
742 &((struct in6_addr *)jp->jp_value)[i],
743 valbuf, sizeof(valbuf)) == NULL) {
744 strerror_r(errno, jail_errmsg,
745 JAIL_ERRMSGLEN);
701
746
702 return (NULL);
703 }
704 break;
705 default:
706 goto unknown_type;
707 }
708 break;
709 default:

--- 131 unchanged lines hidden (view full) ---

841 desc.s[0] == 'B') {
842 jp->jp_ctltype = desc.i;
843 jp->jp_flags |= JP_NOBOOL;
844 jp->jp_valuelen = sizeof(int);
845 return (0);
846 }
847 }
848 }
747 return (NULL);
748 }
749 break;
750 default:
751 goto unknown_type;
752 }
753 break;
754 default:

--- 131 unchanged lines hidden (view full) ---

886 desc.s[0] == 'B') {
887 jp->jp_ctltype = desc.i;
888 jp->jp_flags |= JP_NOBOOL;
889 jp->jp_valuelen = sizeof(int);
890 return (0);
891 }
892 }
893 }
894 unknown_parameter:
849 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
850 "unknown parameter: %s", jp->jp_name);
851 errno = ENOENT;
852 return (-1);
853 }
895 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
896 "unknown parameter: %s", jp->jp_name);
897 errno = ENOENT;
898 return (-1);
899 }
900 mib_desc:
854 mib[1] = 4;
855 desclen = sizeof(desc);
856 if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen,
857 NULL, 0) < 0) {
858 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
859 "sysctl(0.4.%s): %s", jp->jp_name, strerror(errno));
860 return (-1);
861 }

--- 6 unchanged lines hidden (view full) ---

868 isarray = 1;
869 p[-2] = 0;
870 }
871 /* Look for types we understand */
872 jp->jp_ctltype = desc.i;
873 switch (desc.i & CTLTYPE) {
874 case CTLTYPE_INT:
875 if (desc.s[0] == 'B')
901 mib[1] = 4;
902 desclen = sizeof(desc);
903 if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen,
904 NULL, 0) < 0) {
905 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
906 "sysctl(0.4.%s): %s", jp->jp_name, strerror(errno));
907 return (-1);
908 }

--- 6 unchanged lines hidden (view full) ---

915 isarray = 1;
916 p[-2] = 0;
917 }
918 /* Look for types we understand */
919 jp->jp_ctltype = desc.i;
920 switch (desc.i & CTLTYPE) {
921 case CTLTYPE_INT:
922 if (desc.s[0] == 'B')
876 jp->jp_flags |=
877 (desc.s[1] == 'N') ? JP_NOBOOL : JP_BOOL;
923 jp->jp_flags |= JP_BOOL;
924 else if (!strcmp(desc.s, "E,jailsys"))
925 jp->jp_flags |= JP_JAILSYS;
878 case CTLTYPE_UINT:
879 jp->jp_valuelen = sizeof(int);
880 break;
881 case CTLTYPE_LONG:
882 case CTLTYPE_ULONG:
883 jp->jp_valuelen = sizeof(long);
884 break;
885 case CTLTYPE_QUAD:

--- 25 unchanged lines hidden (view full) ---

911 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
912 "sysctl(" SJPARAM ".%s): %s", jp->jp_name,
913 strerror(errno));
914 return (-1);
915 }
916 }
917 break;
918 case CTLTYPE_NODE:
926 case CTLTYPE_UINT:
927 jp->jp_valuelen = sizeof(int);
928 break;
929 case CTLTYPE_LONG:
930 case CTLTYPE_ULONG:
931 jp->jp_valuelen = sizeof(long);
932 break;
933 case CTLTYPE_QUAD:

--- 25 unchanged lines hidden (view full) ---

959 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
960 "sysctl(" SJPARAM ".%s): %s", jp->jp_name,
961 strerror(errno));
962 return (-1);
963 }
964 }
965 break;
966 case CTLTYPE_NODE:
919 /*
920 * A node isn't normally a parameter, but may be a boolean
921 * if its "no" counterpart exists.
922 */
923 nname = noname(jp->jp_name);
924 if (nname == NULL)
925 return (-1);
926 mib[1] = 3;
927 snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", nname);
928 free(nname);
929 miblen = sizeof(mib) - 2 * sizeof(int);
930 if (sysctl(mib, 2, mib + 2, &miblen, desc.s,
931 strlen(desc.s)) < 0) {
932 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
933 "unknown parameter: %s", jp->jp_name);
934 return (-1);
935 }
936 mib[1] = 4;
937 desclen = sizeof(desc);
938 if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen,
967 /* A node might be described by an empty-named child. */
968 mib[1] = 1;
969 mib[(miblen / sizeof(int)) + 2] =
970 mib[(miblen / sizeof(int)) + 1] - 1;
971 miblen += sizeof(int);
972 desclen = sizeof(desc.s);
973 if (sysctl(mib, (miblen / sizeof(int)) + 2, desc.s, &desclen,
939 NULL, 0) < 0) {
940 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
974 NULL, 0) < 0) {
975 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
941 "sysctl(0.4.%s): %s", desc.s, strerror(errno));
976 "sysctl(0.1): %s", strerror(errno));
942 return (-1);
943 }
977 return (-1);
978 }
944 if ((desc.i & CTLTYPE) != CTLTYPE_INT || desc.s[0] != 'B') {
945 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
946 "unknown parameter: %s", jp->jp_name);
947 errno = ENOENT;
948 return (-1);
949 }
950 jp->jp_valuelen = sizeof(int);
951 jp->jp_ctltype = desc.i;
952 jp->jp_flags |= JP_BOOL;
953 break;
979 if (desc.s[desclen - 2] != '.')
980 goto unknown_parameter;
981 goto mib_desc;
954 default:
955 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
956 "unknown type for %s", jp->jp_name);
957 errno = ENOENT;
958 return (-1);
959 }
960 if (isarray) {
961 jp->jp_elemlen = jp->jp_valuelen;

--- 49 unchanged lines hidden --- 		982 default:
983 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
984 "unknown type for %s", jp->jp_name);
985 errno = ENOENT;
986 return (-1);
987 }
988 if (isarray) {
989 jp->jp_elemlen = jp->jp_valuelen;

--- 49 unchanged lines hidden ---