Index: head/lib/libjail/jail.c =================================================================== --- head/lib/libjail/jail.c (revision 275072) +++ head/lib/libjail/jail.c (revision 275073) @@ -1,1069 +1,1069 @@ /*- * Copyright (c) 2009 James Gritton. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include "jail.h" #define SJPARAM "security.jail.param" #define JPS_IN_ADDR 1 #define JPS_IN6_ADDR 2 #define ARRAY_SANITY 5 #define ARRAY_SLOP 5 static int jailparam_import_enum(const char **values, int nvalues, const char *valstr, size_t valsize, int *value); static int jailparam_type(struct jailparam *jp); static char *noname(const char *name); static char *nononame(const char *name); char jail_errmsg[JAIL_ERRMSGLEN]; static const char *bool_values[] = { "false", "true" }; static const char *jailsys_values[] = { "disable", "new", "inherit" }; /* * Import a null-terminated parameter list and set a jail with the flags * and parameters. */ int jail_setv(int flags, ...) { va_list ap, tap; struct jailparam *jp; const char *name, *value; int njp, jid; /* Create the parameter list and import the parameters. */ va_start(ap, flags); va_copy(tap, ap); for (njp = 0; va_arg(tap, char *) != NULL; njp++) (void)va_arg(tap, char *); va_end(tap); jp = alloca(njp * sizeof(struct jailparam)); for (njp = 0; (name = va_arg(ap, char *)) != NULL;) { value = va_arg(ap, char *); if (jailparam_init(jp + njp, name) < 0) goto error; if (jailparam_import(jp + njp++, value) < 0) goto error; } va_end(ap); jid = jailparam_set(jp, njp, flags); jailparam_free(jp, njp); return (jid); error: jailparam_free(jp, njp); va_end(ap); return (-1); } /* * Read a null-terminated parameter list, get the referenced jail, and export * the parameters to the list. */ int jail_getv(int flags, ...) { va_list ap, tap; struct jailparam *jp, *jp_lastjid, *jp_jid, *jp_name, *jp_key; char *valarg, *value; const char *name, *key_value, *lastjid_value, *jid_value, *name_value; int njp, i, jid; /* Create the parameter list and find the key. */ va_start(ap, flags); va_copy(tap, ap); for (njp = 0; va_arg(tap, char *) != NULL; njp++) (void)va_arg(tap, char *); va_end(tap); jp = alloca(njp * sizeof(struct jailparam)); va_copy(tap, ap); jp_lastjid = jp_jid = jp_name = NULL; lastjid_value = jid_value = name_value = NULL; for (njp = 0; (name = va_arg(tap, char *)) != NULL; njp++) { value = va_arg(tap, char *); if (jailparam_init(jp + njp, name) < 0) { va_end(tap); goto error; } if (!strcmp(jp[njp].jp_name, "lastjid")) { jp_lastjid = jp + njp; lastjid_value = value; } else if (!strcmp(jp[njp].jp_name, "jid")) { jp_jid = jp + njp; jid_value = value; } if (!strcmp(jp[njp].jp_name, "name")) { jp_name = jp + njp; name_value = value; } } va_end(tap); /* Import the key parameter. */ if (jp_lastjid != NULL) { jp_key = jp_lastjid; key_value = lastjid_value; } else if (jp_jid != NULL && strtol(jid_value, NULL, 10) != 0) { jp_key = jp_jid; key_value = jid_value; } else if (jp_name != NULL) { jp_key = jp_name; key_value = name_value; } else { strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN); errno = ENOENT; goto error; } if (jailparam_import(jp_key, key_value) < 0) goto error; /* Get the jail and export the parameters. */ jid = jailparam_get(jp, njp, flags); if (jid < 0) goto error; for (i = 0; i < njp; i++) { (void)va_arg(ap, char *); valarg = va_arg(ap, char *); if (jp + i != jp_key) { /* It's up to the caller to ensure there's room. */ if ((jp[i].jp_ctltype & CTLTYPE) == CTLTYPE_STRING) strcpy(valarg, jp[i].jp_value); else { value = jailparam_export(jp + i); if (value == NULL) goto error; strcpy(valarg, value); free(value); } } } jailparam_free(jp, njp); va_end(ap); return (jid); error: jailparam_free(jp, njp); va_end(ap); return (-1); } /* * Return a list of all known parameters. */ int jailparam_all(struct jailparam **jpp) { struct jailparam *jp, *tjp; size_t mlen1, mlen2, buflen; int njp, nlist; int mib1[CTL_MAXNAME], mib2[CTL_MAXNAME - 2]; char buf[MAXPATHLEN]; njp = 0; nlist = 32; jp = malloc(nlist * sizeof(*jp)); if (jp == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } mib1[0] = 0; mib1[1] = 2; mlen1 = CTL_MAXNAME - 2; if (sysctlnametomib(SJPARAM, mib1 + 2, &mlen1) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctlnametomib(" SJPARAM "): %s", strerror(errno)); goto error; } for (;; njp++) { /* Get the next parameter. */ mlen2 = sizeof(mib2); if (sysctl(mib1, mlen1 + 2, mib2, &mlen2, NULL, 0) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(0.2): %s", strerror(errno)); goto error; } if (mib2[0] != mib1[2] || mib2[1] != mib1[3] || mib2[2] != mib1[4]) break; /* Convert it to an ascii name. */ memcpy(mib1 + 2, mib2, mlen2); mlen1 = mlen2 / sizeof(int); mib1[1] = 1; buflen = sizeof(buf); if (sysctl(mib1, mlen1 + 2, buf, &buflen, NULL, 0) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(0.1): %s", strerror(errno)); goto error; } if (buf[buflen - 2] == '.') buf[buflen - 2] = '\0'; /* Add the parameter to the list */ if (njp >= nlist) { nlist *= 2; tjp = realloc(jp, nlist * sizeof(*jp)); if (tjp == NULL) goto error; jp = tjp; } if (jailparam_init(jp + njp, buf + sizeof(SJPARAM)) < 0) goto error; mib1[1] = 2; } jp = realloc(jp, njp * sizeof(*jp)); *jpp = jp; return (njp); error: jailparam_free(jp, njp); free(jp); return (-1); } /* * Clear a jail parameter and copy in its name. */ int jailparam_init(struct jailparam *jp, const char *name) { memset(jp, 0, sizeof(*jp)); jp->jp_name = strdup(name); if (jp->jp_name == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } if (jailparam_type(jp) < 0) { jailparam_free(jp, 1); jp->jp_name = NULL; jp->jp_value = NULL; return (-1); } return (0); } /* * Put a name and value into a jail parameter element, converting the value * to internal form. */ int jailparam_import(struct jailparam *jp, const char *value) { char *p, *ep, *tvalue; const char *avalue; int i, nval, fw; if (value == NULL) return (0); if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) { jp->jp_value = strdup(value); if (jp->jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } return (0); } nval = 1; if (jp->jp_elemlen) { if (value[0] == '\0' || (value[0] == '-' && value[1] == '\0')) { jp->jp_value = strdup(""); if (jp->jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } jp->jp_valuelen = 0; return (0); } for (p = strchr(value, ','); p; p = strchr(p + 1, ',')) nval++; jp->jp_valuelen = jp->jp_elemlen * nval; } jp->jp_value = malloc(jp->jp_valuelen); if (jp->jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } avalue = value; for (i = 0; i < nval; i++) { fw = nval == 1 ? strlen(avalue) : strcspn(avalue, ","); switch (jp->jp_ctltype & CTLTYPE) { case CTLTYPE_INT: if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) { if (!jailparam_import_enum(bool_values, 2, avalue, fw, &((int *)jp->jp_value)[i])) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "%s: " "unknown boolean value \"%.*s\"", jp->jp_name, fw, avalue); errno = EINVAL; goto error; } break; } if (jp->jp_flags & JP_JAILSYS) { /* * Allow setting a jailsys parameter to "new" * in a booleanesque fashion. */ if (value[0] == '\0') ((int *)jp->jp_value)[i] = JAIL_SYS_NEW; else if (!jailparam_import_enum(jailsys_values, sizeof(jailsys_values) / sizeof(jailsys_values[0]), avalue, fw, &((int *)jp->jp_value)[i])) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "%s: " "unknown jailsys value \"%.*s\"", jp->jp_name, fw, avalue); errno = EINVAL; goto error; } break; } ((int *)jp->jp_value)[i] = strtol(avalue, &ep, 10); integer_test: if (ep != avalue + fw) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "%s: non-integer value \"%.*s\"", jp->jp_name, fw, avalue); errno = EINVAL; goto error; } break; case CTLTYPE_UINT: ((unsigned *)jp->jp_value)[i] = strtoul(avalue, &ep, 10); goto integer_test; case CTLTYPE_LONG: ((long *)jp->jp_value)[i] = strtol(avalue, &ep, 10); goto integer_test; case CTLTYPE_ULONG: ((unsigned long *)jp->jp_value)[i] = strtoul(avalue, &ep, 10); goto integer_test; case CTLTYPE_S64: ((int64_t *)jp->jp_value)[i] = strtoimax(avalue, &ep, 10); goto integer_test; case CTLTYPE_U64: ((uint64_t *)jp->jp_value)[i] = strtoumax(avalue, &ep, 10); goto integer_test; case CTLTYPE_STRUCT: tvalue = alloca(fw + 1); strlcpy(tvalue, avalue, fw + 1); switch (jp->jp_structtype) { case JPS_IN_ADDR: if (inet_pton(AF_INET, tvalue, &((struct in_addr *)jp->jp_value)[i]) != 1) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "%s: not an IPv4 address: %s", jp->jp_name, tvalue); errno = EINVAL; goto error; } break; case JPS_IN6_ADDR: if (inet_pton(AF_INET6, tvalue, &((struct in6_addr *)jp->jp_value)[i]) != 1) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "%s: not an IPv6 address: %s", jp->jp_name, tvalue); errno = EINVAL; goto error; } break; default: goto unknown_type; } break; default: unknown_type: snprintf(jail_errmsg, JAIL_ERRMSGLEN, "unknown type for %s", jp->jp_name); errno = ENOENT; goto error; } avalue += fw + 1; } return (0); error: free(jp->jp_value); jp->jp_value = NULL; return (-1); } static int jailparam_import_enum(const char **values, int nvalues, const char *valstr, size_t valsize, int *value) { char *ep; int i; for (i = 0; i < nvalues; i++) if (valsize == strlen(values[i]) && !strncasecmp(valstr, values[i], valsize)) { *value = i; return 1; } *value = strtol(valstr, &ep, 10); return (ep == valstr + valsize); } /* * Put a name and value into a jail parameter element, copying the value * but not altering it. */ int jailparam_import_raw(struct jailparam *jp, void *value, size_t valuelen) { jp->jp_value = value; jp->jp_valuelen = valuelen; jp->jp_flags |= JP_RAWVALUE; return (0); } /* * Run the jail_set and jail_get system calls on a parameter list. */ int jailparam_set(struct jailparam *jp, unsigned njp, int flags) { struct iovec *jiov; char *nname; int i, jid, bool0; unsigned j; jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1)); bool0 = 0; for (i = j = 0; j < njp; j++) { jiov[i].iov_base = jp[j].jp_name; jiov[i].iov_len = strlen(jp[j].jp_name) + 1; i++; if (jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) { /* * Set booleans without values. If one has a value of * zero, change it to (or from) its "no" counterpart. */ jiov[i].iov_base = NULL; jiov[i].iov_len = 0; if (jp[j].jp_value != NULL && jp[j].jp_valuelen == sizeof(int) && !*(int *)jp[j].jp_value) { bool0 = 1; nname = jp[j].jp_flags & JP_BOOL ? noname(jp[j].jp_name) : nononame(jp[j].jp_name); if (nname == NULL) { njp = j; jid = -1; goto done; } jiov[i - 1].iov_base = nname; jiov[i - 1].iov_len = strlen(nname) + 1; } } else { /* * Try to fill in missing values with an empty string. */ if (jp[j].jp_value == NULL && jp[j].jp_valuelen > 0 && jailparam_import(jp + j, "") < 0) { njp = j; jid = -1; goto done; } jiov[i].iov_base = jp[j].jp_value; jiov[i].iov_len = (jp[j].jp_ctltype & CTLTYPE) == CTLTYPE_STRING ? strlen(jp[j].jp_value) + 1 : jp[j].jp_valuelen; } i++; } - *(const void **)&jiov[i].iov_base = "errmsg"; + jiov[i].iov_base = __DECONST(char *, "errmsg"); jiov[i].iov_len = sizeof("errmsg"); i++; jiov[i].iov_base = jail_errmsg; jiov[i].iov_len = JAIL_ERRMSGLEN; i++; jail_errmsg[0] = 0; jid = jail_set(jiov, i, flags); if (jid < 0 && !jail_errmsg[0]) snprintf(jail_errmsg, sizeof(jail_errmsg), "jail_set: %s", strerror(errno)); done: if (bool0) for (j = 0; j < njp; j++) if ((jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) && jp[j].jp_value != NULL && jp[j].jp_valuelen == sizeof(int) && !*(int *)jp[j].jp_value) free(jiov[j * 2].iov_base); return (jid); } int jailparam_get(struct jailparam *jp, unsigned njp, int flags) { struct iovec *jiov; struct jailparam *jp_lastjid, *jp_jid, *jp_name, *jp_key; int i, ai, ki, jid, arrays, sanity; unsigned j; /* * Get the types for all parameters. * Find the key and any array parameters. */ jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1)); jp_lastjid = jp_jid = jp_name = NULL; arrays = 0; for (ai = j = 0; j < njp; j++) { if (!strcmp(jp[j].jp_name, "lastjid")) jp_lastjid = jp + j; else if (!strcmp(jp[j].jp_name, "jid")) jp_jid = jp + j; else if (!strcmp(jp[j].jp_name, "name")) jp_name = jp + j; else if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) { arrays = 1; jiov[ai].iov_base = jp[j].jp_name; jiov[ai].iov_len = strlen(jp[j].jp_name) + 1; ai++; jiov[ai].iov_base = NULL; jiov[ai].iov_len = 0; ai++; } } jp_key = jp_lastjid ? jp_lastjid : jp_jid && jp_jid->jp_valuelen == sizeof(int) && jp_jid->jp_value && *(int *)jp_jid->jp_value ? jp_jid : jp_name; if (jp_key == NULL || jp_key->jp_value == NULL) { strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN); errno = ENOENT; return (-1); } ki = ai; jiov[ki].iov_base = jp_key->jp_name; jiov[ki].iov_len = strlen(jp_key->jp_name) + 1; ki++; jiov[ki].iov_base = jp_key->jp_value; jiov[ki].iov_len = (jp_key->jp_ctltype & CTLTYPE) == CTLTYPE_STRING ? strlen(jp_key->jp_value) + 1 : jp_key->jp_valuelen; ki++; - *(const void **)&jiov[ki].iov_base = "errmsg"; + jiov[ki].iov_base = __DECONST(char *, "errmsg"); jiov[ki].iov_len = sizeof("errmsg"); ki++; jiov[ki].iov_base = jail_errmsg; jiov[ki].iov_len = JAIL_ERRMSGLEN; ki++; jail_errmsg[0] = 0; if (arrays && jail_get(jiov, ki, flags) < 0) { if (!jail_errmsg[0]) snprintf(jail_errmsg, sizeof(jail_errmsg), "jail_get: %s", strerror(errno)); return (-1); } /* Allocate storage for all parameters. */ for (ai = j = 0, i = ki; j < njp; j++) { if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) { ai++; jiov[ai].iov_len += jp[j].jp_elemlen * ARRAY_SLOP; if (jp[j].jp_valuelen >= jiov[ai].iov_len) jiov[ai].iov_len = jp[j].jp_valuelen; else { jp[j].jp_valuelen = jiov[ai].iov_len; if (jp[j].jp_value != NULL) free(jp[j].jp_value); jp[j].jp_value = malloc(jp[j].jp_valuelen); if (jp[j].jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } } jiov[ai].iov_base = jp[j].jp_value; memset(jiov[ai].iov_base, 0, jiov[ai].iov_len); ai++; } else if (jp + j != jp_key) { jiov[i].iov_base = jp[j].jp_name; jiov[i].iov_len = strlen(jp[j].jp_name) + 1; i++; if (jp[j].jp_value == NULL && !(jp[j].jp_flags & JP_RAWVALUE)) { jp[j].jp_value = malloc(jp[j].jp_valuelen); if (jp[j].jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } } jiov[i].iov_base = jp[j].jp_value; jiov[i].iov_len = jp[j].jp_valuelen; memset(jiov[i].iov_base, 0, jiov[i].iov_len); i++; } } /* * Get the prison. If there are array elements, retry a few times * in case their sizes changed from under us. */ for (sanity = 0;; sanity++) { jid = jail_get(jiov, i, flags); if (jid >= 0 || !arrays || sanity == ARRAY_SANITY || errno != EINVAL || jail_errmsg[0]) break; for (ai = j = 0; j < njp; j++) { if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) { ai++; jiov[ai].iov_base = NULL; jiov[ai].iov_len = 0; ai++; } } if (jail_get(jiov, ki, flags) < 0) break; for (ai = j = 0; j < njp; j++) { if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) { ai++; jiov[ai].iov_len += jp[j].jp_elemlen * ARRAY_SLOP; if (jp[j].jp_valuelen >= jiov[ai].iov_len) jiov[ai].iov_len = jp[j].jp_valuelen; else { jp[j].jp_valuelen = jiov[ai].iov_len; if (jp[j].jp_value != NULL) free(jp[j].jp_value); jp[j].jp_value = malloc(jiov[ai].iov_len); if (jp[j].jp_value == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (-1); } } jiov[ai].iov_base = jp[j].jp_value; memset(jiov[ai].iov_base, 0, jiov[ai].iov_len); ai++; } } } if (jid < 0 && !jail_errmsg[0]) snprintf(jail_errmsg, sizeof(jail_errmsg), "jail_get: %s", strerror(errno)); for (ai = j = 0, i = ki; j < njp; j++) { if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) { ai++; jp[j].jp_valuelen = jiov[ai].iov_len; ai++; } else if (jp + j != jp_key) { i++; jp[j].jp_valuelen = jiov[i].iov_len; i++; } } return (jid); } /* * Convert a jail parameter's value to external form. */ char * jailparam_export(struct jailparam *jp) { size_t *valuelens; char *value, *tvalue, **values; size_t valuelen; int i, nval, ival; char valbuf[INET6_ADDRSTRLEN]; if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) { value = strdup(jp->jp_value); if (value == NULL) strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (value); } nval = jp->jp_elemlen ? jp->jp_valuelen / jp->jp_elemlen : 1; if (nval == 0) { value = strdup(""); if (value == NULL) strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (value); } values = alloca(nval * sizeof(char *)); valuelens = alloca(nval * sizeof(size_t)); valuelen = 0; for (i = 0; i < nval; i++) { switch (jp->jp_ctltype & CTLTYPE) { case CTLTYPE_INT: ival = ((int *)jp->jp_value)[i]; if ((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) && (unsigned)ival < 2) { strlcpy(valbuf, bool_values[ival], sizeof(valbuf)); break; } if ((jp->jp_flags & JP_JAILSYS) && (unsigned)ival < sizeof(jailsys_values) / sizeof(jailsys_values[0])) { strlcpy(valbuf, jailsys_values[ival], sizeof(valbuf)); break; } snprintf(valbuf, sizeof(valbuf), "%d", ival); break; case CTLTYPE_UINT: snprintf(valbuf, sizeof(valbuf), "%u", ((unsigned *)jp->jp_value)[i]); break; case CTLTYPE_LONG: snprintf(valbuf, sizeof(valbuf), "%ld", ((long *)jp->jp_value)[i]); break; case CTLTYPE_ULONG: snprintf(valbuf, sizeof(valbuf), "%lu", ((unsigned long *)jp->jp_value)[i]); break; case CTLTYPE_S64: snprintf(valbuf, sizeof(valbuf), "%jd", (intmax_t)((int64_t *)jp->jp_value)[i]); break; case CTLTYPE_U64: snprintf(valbuf, sizeof(valbuf), "%ju", (uintmax_t)((uint64_t *)jp->jp_value)[i]); break; case CTLTYPE_STRUCT: switch (jp->jp_structtype) { case JPS_IN_ADDR: if (inet_ntop(AF_INET, &((struct in_addr *)jp->jp_value)[i], valbuf, sizeof(valbuf)) == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (NULL); } break; case JPS_IN6_ADDR: if (inet_ntop(AF_INET6, &((struct in6_addr *)jp->jp_value)[i], valbuf, sizeof(valbuf)) == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (NULL); } break; default: goto unknown_type; } break; default: unknown_type: snprintf(jail_errmsg, JAIL_ERRMSGLEN, "unknown type for %s", jp->jp_name); errno = ENOENT; return (NULL); } valuelens[i] = strlen(valbuf) + 1; valuelen += valuelens[i]; values[i] = alloca(valuelens[i]); strcpy(values[i], valbuf); } value = malloc(valuelen); if (value == NULL) strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); else { tvalue = value; for (i = 0; i < nval; i++) { strcpy(tvalue, values[i]); if (i < nval - 1) { tvalue += valuelens[i]; tvalue[-1] = ','; } } } return (value); } /* * Free the contents of a jail parameter list (but not the list itself). */ void jailparam_free(struct jailparam *jp, unsigned njp) { unsigned j; for (j = 0; j < njp; j++) { free(jp[j].jp_name); if (!(jp[j].jp_flags & JP_RAWVALUE)) free(jp[j].jp_value); } } /* * Find a parameter's type and size from its MIB. */ static int jailparam_type(struct jailparam *jp) { char *p, *name, *nname; size_t miblen, desclen; int i, isarray; struct { int i; char s[MAXPATHLEN]; } desc; int mib[CTL_MAXNAME]; /* The "lastjid" parameter isn't real. */ name = jp->jp_name; if (!strcmp(name, "lastjid")) { jp->jp_valuelen = sizeof(int); jp->jp_ctltype = CTLTYPE_INT | CTLFLAG_WR; return (0); } /* Find the sysctl that describes the parameter. */ mib[0] = 0; mib[1] = 3; snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", name); miblen = sizeof(mib) - 2 * sizeof(int); if (sysctl(mib, 2, mib + 2, &miblen, desc.s, strlen(desc.s)) < 0) { if (errno != ENOENT) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(0.3.%s): %s", name, strerror(errno)); return (-1); } /* * The parameter probably doesn't exist. But it might be * the "no" counterpart to a boolean. */ nname = nononame(name); if (nname == NULL) { unknown_parameter: snprintf(jail_errmsg, JAIL_ERRMSGLEN, "unknown parameter: %s", jp->jp_name); errno = ENOENT; return (-1); } name = alloca(strlen(nname) + 1); strcpy(name, nname); free(nname); snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", name); miblen = sizeof(mib) - 2 * sizeof(int); if (sysctl(mib, 2, mib + 2, &miblen, desc.s, strlen(desc.s)) < 0) goto unknown_parameter; jp->jp_flags |= JP_NOBOOL; } mib_desc: mib[1] = 4; desclen = sizeof(desc); if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen, NULL, 0) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(0.4.%s): %s", name, strerror(errno)); return (-1); } jp->jp_ctltype = desc.i; /* If this came from removing a "no", it better be a boolean. */ if (jp->jp_flags & JP_NOBOOL) { if ((desc.i & CTLTYPE) == CTLTYPE_INT && desc.s[0] == 'B') { jp->jp_valuelen = sizeof(int); return (0); } else if ((desc.i & CTLTYPE) != CTLTYPE_NODE) goto unknown_parameter; } /* See if this is an array type. */ p = strchr(desc.s, '\0'); isarray = 0; if (p - 2 < desc.s || strcmp(p - 2, ",a")) isarray = 0; else { isarray = 1; p[-2] = 0; } /* Look for types we understand. */ switch (desc.i & CTLTYPE) { case CTLTYPE_INT: if (desc.s[0] == 'B') jp->jp_flags |= JP_BOOL; else if (!strcmp(desc.s, "E,jailsys")) jp->jp_flags |= JP_JAILSYS; case CTLTYPE_UINT: jp->jp_valuelen = sizeof(int); break; case CTLTYPE_LONG: case CTLTYPE_ULONG: jp->jp_valuelen = sizeof(long); break; case CTLTYPE_S64: case CTLTYPE_U64: jp->jp_valuelen = sizeof(int64_t); break; case CTLTYPE_STRING: desc.s[0] = 0; desclen = sizeof(desc.s); if (sysctl(mib + 2, miblen / sizeof(int), desc.s, &desclen, NULL, 0) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(" SJPARAM ".%s): %s", name, strerror(errno)); return (-1); } jp->jp_valuelen = strtoul(desc.s, NULL, 10); break; case CTLTYPE_STRUCT: if (!strcmp(desc.s, "S,in_addr")) { jp->jp_structtype = JPS_IN_ADDR; jp->jp_valuelen = sizeof(struct in_addr); } else if (!strcmp(desc.s, "S,in6_addr")) { jp->jp_structtype = JPS_IN6_ADDR; jp->jp_valuelen = sizeof(struct in6_addr); } else { desclen = 0; if (sysctl(mib + 2, miblen / sizeof(int), NULL, &jp->jp_valuelen, NULL, 0) < 0) { snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(" SJPARAM ".%s): %s", name, strerror(errno)); return (-1); } } break; case CTLTYPE_NODE: /* * A node might be described by an empty-named child, * which would be immediately before or after the node itself. */ mib[1] = 1; miblen += sizeof(int); for (i = -1; i <= 1; i += 2) { mib[(miblen / sizeof(int)) + 1] = mib[(miblen / sizeof(int))] + i; desclen = sizeof(desc.s); if (sysctl(mib, (miblen / sizeof(int)) + 2, desc.s, &desclen, NULL, 0) < 0) { if (errno == ENOENT) continue; snprintf(jail_errmsg, JAIL_ERRMSGLEN, "sysctl(0.1): %s", strerror(errno)); return (-1); } if (desclen == sizeof(SJPARAM) + strlen(name) + 2 && memcmp(SJPARAM ".", desc.s, sizeof(SJPARAM)) == 0 && memcmp(name, desc.s + sizeof(SJPARAM), desclen - sizeof(SJPARAM) - 2) == 0 && desc.s[desclen - 2] == '.') goto mib_desc; } goto unknown_parameter; default: snprintf(jail_errmsg, JAIL_ERRMSGLEN, "unknown type for %s", jp->jp_name); errno = ENOENT; return (-1); } if (isarray) { jp->jp_elemlen = jp->jp_valuelen; jp->jp_valuelen = 0; } return (0); } /* * Change a boolean parameter name into its "no" counterpart or vice versa. */ static char * noname(const char *name) { char *nname, *p; nname = malloc(strlen(name) + 3); if (nname == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (NULL); } p = strrchr(name, '.'); if (p != NULL) sprintf(nname, "%.*s.no%s", (int)(p - name), name, p + 1); else sprintf(nname, "no%s", name); return (nname); } static char * nononame(const char *name) { char *p, *nname; p = strrchr(name, '.'); if (strncmp(p ? p + 1 : name, "no", 2)) { snprintf(jail_errmsg, sizeof(jail_errmsg), "mismatched boolean: %s", name); errno = EINVAL; return (NULL); } nname = malloc(strlen(name) - 1); if (nname == NULL) { strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); return (NULL); } if (p != NULL) sprintf(nname, "%.*s.%s", (int)(p - name), name, p + 3); else strcpy(nname, name + 2); return (nname); } Index: head/lib/libjail/jail_getid.c =================================================================== --- head/lib/libjail/jail_getid.c (revision 275072) +++ head/lib/libjail/jail_getid.c (revision 275073) @@ -1,108 +1,108 @@ /*- * Copyright (c) 2009 James Gritton. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include "jail.h" /* * Return the JID corresponding to a jail name. */ int jail_getid(const char *name) { char *ep; int jid; struct iovec jiov[4]; jid = strtoul(name, &ep, 10); if (*name && !*ep) return jid; - *(const void **)&jiov[0].iov_base = "name"; + jiov[0].iov_base = __DECONST(char *, "name"); jiov[0].iov_len = sizeof("name"); jiov[1].iov_len = strlen(name) + 1; jiov[1].iov_base = alloca(jiov[1].iov_len); strcpy(jiov[1].iov_base, name); - *(const void **)&jiov[2].iov_base = "errmsg"; + jiov[2].iov_base = __DECONST(char *, "errmsg"); jiov[2].iov_len = sizeof("errmsg"); jiov[3].iov_base = jail_errmsg; jiov[3].iov_len = JAIL_ERRMSGLEN; jail_errmsg[0] = 0; jid = jail_get(jiov, 4, 0); if (jid < 0 && !jail_errmsg[0]) snprintf(jail_errmsg, JAIL_ERRMSGLEN, "jail_get: %s", strerror(errno)); return jid; } /* * Return the name corresponding to a JID. */ char * jail_getname(int jid) { struct iovec jiov[6]; char *name; char namebuf[MAXHOSTNAMELEN]; - *(const void **)&jiov[0].iov_base = "jid"; + jiov[0].iov_base = __DECONST(char *, "jid"); jiov[0].iov_len = sizeof("jid"); jiov[1].iov_base = &jid; jiov[1].iov_len = sizeof(jid); - *(const void **)&jiov[2].iov_base = "name"; + jiov[2].iov_base = __DECONST(char *, "name"); jiov[2].iov_len = sizeof("name"); jiov[3].iov_base = namebuf; jiov[3].iov_len = sizeof(namebuf); - *(const void **)&jiov[4].iov_base = "errmsg"; + jiov[4].iov_base = __DECONST(char *, "errmsg"); jiov[4].iov_len = sizeof("errmsg"); jiov[5].iov_base = jail_errmsg; jiov[5].iov_len = JAIL_ERRMSGLEN; jail_errmsg[0] = 0; jid = jail_get(jiov, 6, 0); if (jid < 0) { if (!jail_errmsg[0]) snprintf(jail_errmsg, JAIL_ERRMSGLEN, "jail_get: %s", strerror(errno)); return NULL; } else { name = strdup(namebuf); if (name == NULL) strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN); } return name; } Index: head/usr.sbin/jail/command.c =================================================================== --- head/usr.sbin/jail/command.c (revision 275072) +++ head/usr.sbin/jail/command.c (revision 275073) @@ -1,943 +1,942 @@ /*- * Copyright (c) 2011 James Gritton * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "jailp.h" #define DEFAULT_STOP_TIMEOUT 10 #define PHASH_SIZE 256 LIST_HEAD(phhead, phash); struct phash { LIST_ENTRY(phash) le; struct cfjail *j; pid_t pid; }; int paralimit = -1; extern char **environ; static int run_command(struct cfjail *j); static int add_proc(struct cfjail *j, pid_t pid); static void clear_procs(struct cfjail *j); static struct cfjail *find_proc(pid_t pid); static int term_procs(struct cfjail *j); static int get_user_info(struct cfjail *j, const char *username, const struct passwd **pwdp, login_cap_t **lcapp); static int check_path(struct cfjail *j, const char *pname, const char *path, int isfile, const char *umount_type); static struct cfjails sleeping = TAILQ_HEAD_INITIALIZER(sleeping); static struct cfjails runnable = TAILQ_HEAD_INITIALIZER(runnable); static struct cfstring dummystring = { .len = 1 }; static struct phhead phash[PHASH_SIZE]; static int kq; /* * Run the next command associated with a jail. */ int next_command(struct cfjail *j) { enum intparam comparam; int create_failed, stopping; if (paralimit == 0) { requeue(j, &runnable); return 1; } create_failed = (j->flags & (JF_STOP | JF_FAILED)) == JF_FAILED; stopping = (j->flags & JF_STOP) != 0; comparam = *j->comparam; for (;;) { if (j->comstring == NULL) { j->comparam += create_failed ? -1 : 1; switch ((comparam = *j->comparam)) { case IP__NULL: return 0; case IP_MOUNT_DEVFS: if (!bool_param(j->intparams[IP_MOUNT_DEVFS])) continue; j->comstring = &dummystring; break; case IP_MOUNT_FDESCFS: if (!bool_param(j->intparams[IP_MOUNT_FDESCFS])) continue; j->comstring = &dummystring; case IP__OP: case IP_STOP_TIMEOUT: j->comstring = &dummystring; break; default: if (j->intparams[comparam] == NULL) continue; j->comstring = create_failed || (stopping && (j->intparams[comparam]->flags & PF_REV)) ? TAILQ_LAST(&j->intparams[comparam]->val, cfstrings) : TAILQ_FIRST(&j->intparams[comparam]->val); } } else { j->comstring = j->comstring == &dummystring ? NULL : create_failed || (stopping && (j->intparams[comparam]->flags & PF_REV)) ? TAILQ_PREV(j->comstring, cfstrings, tq) : TAILQ_NEXT(j->comstring, tq); } if (j->comstring == NULL || j->comstring->len == 0 || (create_failed && (comparam == IP_EXEC_PRESTART || comparam == IP_EXEC_START || comparam == IP_COMMAND || comparam == IP_EXEC_POSTSTART))) continue; switch (run_command(j)) { case -1: failed(j); /* FALLTHROUGH */ case 1: return 1; } } } /* * Check command exit status */ int finish_command(struct cfjail *j) { int error; if (!(j->flags & JF_SLEEPQ)) return 0; j->flags &= ~JF_SLEEPQ; if (*j->comparam == IP_STOP_TIMEOUT) { j->flags &= ~JF_TIMEOUT; j->pstatus = 0; return 0; } paralimit++; if (!TAILQ_EMPTY(&runnable)) requeue(TAILQ_FIRST(&runnable), &ready); error = 0; if (j->flags & JF_TIMEOUT) { j->flags &= ~JF_TIMEOUT; if (*j->comparam != IP_STOP_TIMEOUT) { jail_warnx(j, "%s: timed out", j->comline); failed(j); error = -1; } else if (verbose > 0) jail_note(j, "timed out\n"); } else if (j->pstatus != 0) { if (WIFSIGNALED(j->pstatus)) jail_warnx(j, "%s: exited on signal %d", j->comline, WTERMSIG(j->pstatus)); else jail_warnx(j, "%s: failed", j->comline); j->pstatus = 0; failed(j); error = -1; } free(j->comline); j->comline = NULL; return error; } /* * Check for finished processes or timeouts. */ struct cfjail * next_proc(int nonblock) { struct kevent ke; struct timespec ts; struct timespec *tsp; struct cfjail *j; if (!TAILQ_EMPTY(&sleeping)) { again: tsp = NULL; if ((j = TAILQ_FIRST(&sleeping)) && j->timeout.tv_sec) { clock_gettime(CLOCK_REALTIME, &ts); ts.tv_sec = j->timeout.tv_sec - ts.tv_sec; ts.tv_nsec = j->timeout.tv_nsec - ts.tv_nsec; if (ts.tv_nsec < 0) { ts.tv_sec--; ts.tv_nsec += 1000000000; } if (ts.tv_sec < 0 || (ts.tv_sec == 0 && ts.tv_nsec == 0)) { j->flags |= JF_TIMEOUT; clear_procs(j); return j; } tsp = &ts; } if (nonblock) { ts.tv_sec = 0; ts.tv_nsec = 0; tsp = &ts; } switch (kevent(kq, NULL, 0, &ke, 1, tsp)) { case -1: if (errno != EINTR) err(1, "kevent"); goto again; case 0: if (!nonblock) { j = TAILQ_FIRST(&sleeping); j->flags |= JF_TIMEOUT; clear_procs(j); return j; } break; case 1: (void)waitpid(ke.ident, NULL, WNOHANG); if ((j = find_proc(ke.ident))) { j->pstatus = ke.data; return j; } goto again; } } return NULL; } /* * Run a single command for a jail, possible inside the jail. */ static int run_command(struct cfjail *j) { const struct passwd *pwd; const struct cfstring *comstring, *s; login_cap_t *lcap; - char **argv; - char *cs, *comcs, *devpath; + const char **argv; + char *acs, *cs, *comcs, *devpath; const char *jidstr, *conslog, *path, *ruleset, *term, *username; enum intparam comparam; size_t comlen; pid_t pid; int argc, bg, clean, consfd, down, fib, i, injail, sjuser, timeout; #if defined(INET) || defined(INET6) char *addr, *extrap, *p, *val; #endif static char *cleanenv; /* Perform some operations that aren't actually commands */ comparam = *j->comparam; down = j->flags & (JF_STOP | JF_FAILED); switch (comparam) { case IP_STOP_TIMEOUT: return term_procs(j); case IP__OP: if (down) { if (jail_remove(j->jid) < 0 && errno == EPERM) { jail_warnx(j, "jail_remove: %s", strerror(errno)); return -1; } if (verbose > 0 || (verbose == 0 && (j->flags & JF_STOP ? note_remove : j->name != NULL))) jail_note(j, "removed\n"); j->jid = -1; if (j->flags & JF_STOP) dep_done(j, DF_LIGHT); else j->flags &= ~JF_PERSIST; } else { if (create_jail(j) < 0) return -1; if (iflag) printf("%d\n", j->jid); if (verbose >= 0 && (j->name || verbose > 0)) jail_note(j, "created\n"); dep_done(j, DF_LIGHT); } return 0; default: ; } /* * Collect exec arguments. Internal commands for network and * mounting build their own argument lists. */ comstring = j->comstring; bg = 0; switch (comparam) { #ifdef INET case IP__IP4_IFADDR: argc = 0; val = alloca(strlen(comstring->s) + 1); strcpy(val, comstring->s); cs = val; extrap = NULL; while ((p = strchr(cs, ' ')) != NULL && strlen(p) > 1) { if (extrap == NULL) { *p = '\0'; extrap = p + 1; } cs = p + 1; argc++; } argv = alloca((8 + argc) * sizeof(char *)); - *(const char **)&argv[0] = _PATH_IFCONFIG; + argv[0] = _PATH_IFCONFIG; if ((cs = strchr(val, '|'))) { - argv[1] = alloca(cs - val + 1); - strlcpy(argv[1], val, cs - val + 1); + argv[1] = acs = alloca(cs - val + 1); + strlcpy(acs, val, cs - val + 1); addr = cs + 1; } else { - *(const char **)&argv[1] = - string_param(j->intparams[IP_INTERFACE]); + argv[1] = string_param(j->intparams[IP_INTERFACE]); addr = val; } - *(const char **)&argv[2] = "inet"; + argv[2] = "inet"; if (!(cs = strchr(addr, '/'))) { argv[3] = addr; - *(const char **)&argv[4] = "netmask"; - *(const char **)&argv[5] = "255.255.255.255"; + argv[4] = "netmask"; + argv[5] = "255.255.255.255"; argc = 6; } else if (strchr(cs + 1, '.')) { - argv[3] = alloca(cs - addr + 1); - strlcpy(argv[3], addr, cs - addr + 1); - *(const char **)&argv[4] = "netmask"; - *(const char **)&argv[5] = cs + 1; + argv[3] = acs = alloca(cs - addr + 1); + strlcpy(acs, addr, cs - addr + 1); + argv[4] = "netmask"; + argv[5] = cs + 1; argc = 6; } else { argv[3] = addr; argc = 4; } if (!down) { - for (cs = strtok(extrap, " "); cs; cs = strtok(NULL, " ")) { + for (cs = strtok(extrap, " "); cs; + cs = strtok(NULL, " ")) { size_t len = strlen(cs) + 1; - argv[argc] = alloca(len); - strlcpy(argv[argc++], cs, len); + argv[argc++] = acs = alloca(len); + strlcpy(acs, cs, len); } } - *(const char **)&argv[argc] = down ? "-alias" : "alias"; + argv[argc] = down ? "-alias" : "alias"; argv[argc + 1] = NULL; break; #endif #ifdef INET6 case IP__IP6_IFADDR: argc = 0; val = alloca(strlen(comstring->s) + 1); strcpy(val, comstring->s); cs = val; extrap = NULL; while ((p = strchr(cs, ' ')) != NULL && strlen(p) > 1) { if (extrap == NULL) { *p = '\0'; extrap = p + 1; } cs = p + 1; argc++; } argv = alloca((8 + argc) * sizeof(char *)); - *(const char **)&argv[0] = _PATH_IFCONFIG; + argv[0] = _PATH_IFCONFIG; if ((cs = strchr(val, '|'))) { - argv[1] = alloca(cs - val + 1); - strlcpy(argv[1], val, cs - val + 1); + argv[1] = acs = alloca(cs - val + 1); + strlcpy(acs, val, cs - val + 1); addr = cs + 1; } else { - *(const char **)&argv[1] = - string_param(j->intparams[IP_INTERFACE]); + argv[1] = string_param(j->intparams[IP_INTERFACE]); addr = val; } - *(const char **)&argv[2] = "inet6"; + argv[2] = "inet6"; argv[3] = addr; if (!(cs = strchr(addr, '/'))) { - *(const char **)&argv[4] = "prefixlen"; - *(const char **)&argv[5] = "128"; + argv[4] = "prefixlen"; + argv[5] = "128"; argc = 6; } else argc = 4; if (!down) { - for (cs = strtok(extrap, " "); cs; cs = strtok(NULL, " ")) { + for (cs = strtok(extrap, " "); cs; + cs = strtok(NULL, " ")) { size_t len = strlen(cs) + 1; - argv[argc] = alloca(len); - strlcpy(argv[argc++], cs, len); + argv[argc++] = acs = alloca(len); + strlcpy(acs, cs, len); } } - *(const char **)&argv[argc] = down ? "-alias" : "alias"; + argv[argc] = down ? "-alias" : "alias"; argv[argc + 1] = NULL; break; #endif case IP_VNET_INTERFACE: argv = alloca(5 * sizeof(char *)); - *(const char **)&argv[0] = _PATH_IFCONFIG; + argv[0] = _PATH_IFCONFIG; argv[1] = comstring->s; - *(const char **)&argv[2] = down ? "-vnet" : "vnet"; + argv[2] = down ? "-vnet" : "vnet"; jidstr = string_param(j->intparams[KP_JID]); - *(const char **)&argv[3] = - jidstr ? jidstr : string_param(j->intparams[KP_NAME]); + argv[3] = jidstr ? jidstr : string_param(j->intparams[KP_NAME]); argv[4] = NULL; break; case IP_MOUNT: case IP__MOUNT_FROM_FSTAB: argv = alloca(8 * sizeof(char *)); comcs = alloca(comstring->len + 1); strcpy(comcs, comstring->s); argc = 0; for (cs = strtok(comcs, " \t\f\v\r\n"); cs && argc < 4; cs = strtok(NULL, " \t\f\v\r\n")) argv[argc++] = cs; if (argc == 0) return 0; if (argc < 3) { jail_warnx(j, "%s: %s: missing information", j->intparams[comparam]->name, comstring->s); return -1; } if (check_path(j, j->intparams[comparam]->name, argv[1], 0, down ? argv[2] : NULL) < 0) return -1; if (down) { argv[4] = NULL; argv[3] = argv[1]; - *(const char **)&argv[0] = "/sbin/umount"; + argv[0] = "/sbin/umount"; } else { if (argc == 4) { argv[7] = NULL; argv[6] = argv[1]; argv[5] = argv[0]; argv[4] = argv[3]; - *(const char **)&argv[3] = "-o"; + argv[3] = "-o"; } else { argv[5] = NULL; argv[4] = argv[1]; argv[3] = argv[0]; } - *(const char **)&argv[0] = _PATH_MOUNT; + argv[0] = _PATH_MOUNT; } - *(const char **)&argv[1] = "-t"; + argv[1] = "-t"; break; case IP_MOUNT_DEVFS: argv = alloca(7 * sizeof(char *)); path = string_param(j->intparams[KP_PATH]); if (path == NULL) { jail_warnx(j, "mount.devfs: no path"); return -1; } devpath = alloca(strlen(path) + 5); sprintf(devpath, "%s/dev", path); if (check_path(j, "mount.devfs", devpath, 0, down ? "devfs" : NULL) < 0) return -1; if (down) { - *(const char **)&argv[0] = "/sbin/umount"; + argv[0] = "/sbin/umount"; argv[1] = devpath; argv[2] = NULL; } else { - *(const char **)&argv[0] = _PATH_MOUNT; - *(const char **)&argv[1] = "-t"; - *(const char **)&argv[2] = "devfs"; + argv[0] = _PATH_MOUNT; + argv[1] = "-t"; + argv[2] = "devfs"; ruleset = string_param(j->intparams[KP_DEVFS_RULESET]); if (!ruleset) ruleset = "4"; /* devfsrules_jail */ - argv[3] = alloca(11 + strlen(ruleset)); - sprintf(argv[3], "-oruleset=%s", ruleset); - *(const char **)&argv[4] = "."; + argv[3] = acs = alloca(11 + strlen(ruleset)); + sprintf(acs, "-oruleset=%s", ruleset); + argv[4] = "."; argv[5] = devpath; argv[6] = NULL; } break; case IP_MOUNT_FDESCFS: argv = alloca(7 * sizeof(char *)); path = string_param(j->intparams[KP_PATH]); if (path == NULL) { jail_warnx(j, "mount.fdescfs: no path"); return -1; } devpath = alloca(strlen(path) + 8); sprintf(devpath, "%s/dev/fd", path); if (check_path(j, "mount.fdescfs", devpath, 0, down ? "fdescfs" : NULL) < 0) return -1; if (down) { - *(const char **)&argv[0] = "/sbin/umount"; + argv[0] = "/sbin/umount"; argv[1] = devpath; argv[2] = NULL; } else { - *(const char **)&argv[0] = _PATH_MOUNT; - *(const char **)&argv[1] = "-t"; - *(const char **)&argv[2] = "fdescfs"; - *(const char **)&argv[3] = "."; + argv[0] = _PATH_MOUNT; + argv[1] = "-t"; + argv[2] = "fdescfs"; + argv[3] = "."; argv[4] = devpath; argv[5] = NULL; } break; case IP_COMMAND: if (j->name != NULL) goto default_command; argc = 0; TAILQ_FOREACH(s, &j->intparams[IP_COMMAND]->val, tq) argc++; argv = alloca((argc + 1) * sizeof(char *)); argc = 0; TAILQ_FOREACH(s, &j->intparams[IP_COMMAND]->val, tq) argv[argc++] = s->s; argv[argc] = NULL; j->comstring = &dummystring; break; default: default_command: if ((cs = strpbrk(comstring->s, "!\"$&'()*;<>?[\\]`{|}~")) && !(cs[0] == '&' && cs[1] == '\0')) { argv = alloca(4 * sizeof(char *)); - *(const char **)&argv[0] = _PATH_BSHELL; - *(const char **)&argv[1] = "-c"; + argv[0] = _PATH_BSHELL; + argv[1] = "-c"; argv[2] = comstring->s; argv[3] = NULL; } else { if (cs) { *cs = 0; bg = 1; } comcs = alloca(comstring->len + 1); strcpy(comcs, comstring->s); argc = 0; for (cs = strtok(comcs, " \t\f\v\r\n"); cs; cs = strtok(NULL, " \t\f\v\r\n")) argc++; argv = alloca((argc + 1) * sizeof(char *)); strcpy(comcs, comstring->s); argc = 0; for (cs = strtok(comcs, " \t\f\v\r\n"); cs; cs = strtok(NULL, " \t\f\v\r\n")) argv[argc++] = cs; argv[argc] = NULL; } } if (argv[0] == NULL) return 0; if (int_param(j->intparams[IP_EXEC_TIMEOUT], &timeout) && timeout != 0) { clock_gettime(CLOCK_REALTIME, &j->timeout); j->timeout.tv_sec += timeout; } else j->timeout.tv_sec = 0; injail = comparam == IP_EXEC_START || comparam == IP_COMMAND || comparam == IP_EXEC_STOP; clean = bool_param(j->intparams[IP_EXEC_CLEAN]); username = string_param(j->intparams[injail ? IP_EXEC_JAIL_USER : IP_EXEC_SYSTEM_USER]); sjuser = bool_param(j->intparams[IP_EXEC_SYSTEM_JAIL_USER]); consfd = 0; if (injail && (conslog = string_param(j->intparams[IP_EXEC_CONSOLELOG]))) { if (check_path(j, "exec.consolelog", conslog, 1, NULL) < 0) return -1; consfd = open(conslog, O_WRONLY | O_CREAT | O_APPEND, DEFFILEMODE); if (consfd < 0) { jail_warnx(j, "open %s: %s", conslog, strerror(errno)); return -1; } } comlen = 0; for (i = 0; argv[i]; i++) comlen += strlen(argv[i]) + 1; j->comline = cs = emalloc(comlen); for (i = 0; argv[i]; i++) { strcpy(cs, argv[i]); if (argv[i + 1]) { cs += strlen(argv[i]) + 1; cs[-1] = ' '; } } if (verbose > 0) jail_note(j, "run command%s%s%s: %s\n", injail ? " in jail" : "", username ? " as " : "", username ? username : "", j->comline); pid = fork(); if (pid < 0) err(1, "fork"); if (pid > 0) { if (bg || !add_proc(j, pid)) { free(j->comline); j->comline = NULL; return 0; } else { paralimit--; return 1; } } if (bg) setsid(); /* Set up the environment and run the command */ pwd = NULL; lcap = NULL; if ((clean || username) && injail && sjuser && get_user_info(j, username, &pwd, &lcap) < 0) exit(1); if (injail) { /* jail_attach won't chdir along with its chroot. */ path = string_param(j->intparams[KP_PATH]); if (path && chdir(path) < 0) { jail_warnx(j, "chdir %s: %s", path, strerror(errno)); exit(1); } if (int_param(j->intparams[IP_EXEC_FIB], &fib) && setfib(fib) < 0) { jail_warnx(j, "setfib: %s", strerror(errno)); exit(1); } if (jail_attach(j->jid) < 0) { jail_warnx(j, "jail_attach: %s", strerror(errno)); exit(1); } } if (clean || username) { if (!(injail && sjuser) && get_user_info(j, username, &pwd, &lcap) < 0) exit(1); if (clean) { term = getenv("TERM"); environ = &cleanenv; setenv("PATH", "/bin:/usr/bin", 0); if (term != NULL) setenv("TERM", term, 1); } if (setusercontext(lcap, pwd, pwd->pw_uid, username ? LOGIN_SETALL & ~LOGIN_SETGROUP & ~LOGIN_SETLOGIN : LOGIN_SETPATH | LOGIN_SETENV) < 0) { jail_warnx(j, "setusercontext %s: %s", pwd->pw_name, strerror(errno)); exit(1); } login_close(lcap); setenv("USER", pwd->pw_name, 1); setenv("HOME", pwd->pw_dir, 1); setenv("SHELL", *pwd->pw_shell ? pwd->pw_shell : _PATH_BSHELL, 1); if (clean && chdir(pwd->pw_dir) < 0) { jail_warnx(j, "chdir %s: %s", pwd->pw_dir, strerror(errno)); exit(1); } endpwent(); } if (consfd != 0 && (dup2(consfd, 1) < 0 || dup2(consfd, 2) < 0)) { jail_warnx(j, "exec.consolelog: %s", strerror(errno)); exit(1); } closefrom(3); - execvp(argv[0], argv); + execvp(argv[0], __DECONST(char *const*, argv)); jail_warnx(j, "exec %s: %s", argv[0], strerror(errno)); exit(1); } /* * Add a process to the hash, tied to a jail. */ static int add_proc(struct cfjail *j, pid_t pid) { struct kevent ke; struct cfjail *tj; struct phash *ph; if (!kq && (kq = kqueue()) < 0) err(1, "kqueue"); EV_SET(&ke, pid, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL); if (kevent(kq, &ke, 1, NULL, 0, NULL) < 0) { if (errno == ESRCH) return 0; err(1, "kevent"); } ph = emalloc(sizeof(struct phash)); ph->j = j; ph->pid = pid; LIST_INSERT_HEAD(&phash[pid % PHASH_SIZE], ph, le); j->nprocs++; j->flags |= JF_SLEEPQ; if (j->timeout.tv_sec == 0) requeue(j, &sleeping); else { /* File the jail in the sleep queue acording to its timeout. */ TAILQ_REMOVE(j->queue, j, tq); TAILQ_FOREACH(tj, &sleeping, tq) { if (!tj->timeout.tv_sec || j->timeout.tv_sec < tj->timeout.tv_sec || (j->timeout.tv_sec == tj->timeout.tv_sec && j->timeout.tv_nsec <= tj->timeout.tv_nsec)) { TAILQ_INSERT_BEFORE(tj, j, tq); break; } } if (tj == NULL) TAILQ_INSERT_TAIL(&sleeping, j, tq); j->queue = &sleeping; } return 1; } /* * Remove any processes from the hash that correspond to a jail. */ static void clear_procs(struct cfjail *j) { struct kevent ke; struct phash *ph, *tph; int i; j->nprocs = 0; for (i = 0; i < PHASH_SIZE; i++) LIST_FOREACH_SAFE(ph, &phash[i], le, tph) if (ph->j == j) { EV_SET(&ke, ph->pid, EVFILT_PROC, EV_DELETE, NOTE_EXIT, 0, NULL); (void)kevent(kq, &ke, 1, NULL, 0, NULL); LIST_REMOVE(ph, le); free(ph); } } /* * Find the jail that corresponds to an exited process. */ static struct cfjail * find_proc(pid_t pid) { struct cfjail *j; struct phash *ph; LIST_FOREACH(ph, &phash[pid % PHASH_SIZE], le) if (ph->pid == pid) { j = ph->j; LIST_REMOVE(ph, le); free(ph); return --j->nprocs ? NULL : j; } return NULL; } /* * Send SIGTERM to all processes in a jail and wait for them to die. */ static int term_procs(struct cfjail *j) { struct kinfo_proc *ki; int i, noted, pcnt, timeout; static kvm_t *kd; if (!int_param(j->intparams[IP_STOP_TIMEOUT], &timeout)) timeout = DEFAULT_STOP_TIMEOUT; else if (timeout == 0) return 0; if (kd == NULL) { kd = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL); if (kd == NULL) return 0; } ki = kvm_getprocs(kd, KERN_PROC_PROC, 0, &pcnt); if (ki == NULL) return 0; noted = 0; for (i = 0; i < pcnt; i++) if (ki[i].ki_jid == j->jid && kill(ki[i].ki_pid, SIGTERM) == 0) { (void)add_proc(j, ki[i].ki_pid); if (verbose > 0) { if (!noted) { noted = 1; jail_note(j, "sent SIGTERM to:"); } printf(" %d", ki[i].ki_pid); } } if (noted) printf("\n"); if (j->nprocs > 0) { clock_gettime(CLOCK_REALTIME, &j->timeout); j->timeout.tv_sec += timeout; return 1; } return 0; } /* * Look up a user in the passwd and login.conf files. */ static int get_user_info(struct cfjail *j, const char *username, const struct passwd **pwdp, login_cap_t **lcapp) { const struct passwd *pwd; *pwdp = pwd = username ? getpwnam(username) : getpwuid(getuid()); if (pwd == NULL) { if (errno) jail_warnx(j, "getpwnam%s%s: %s", username ? " " : "", username ? username : "", strerror(errno)); else if (username) jail_warnx(j, "%s: no such user", username); else jail_warnx(j, "unknown uid %d", getuid()); return -1; } *lcapp = login_getpwclass(pwd); if (*lcapp == NULL) { jail_warnx(j, "getpwclass %s: %s", pwd->pw_name, strerror(errno)); return -1; } /* Set the groups while the group file is still available */ if (initgroups(pwd->pw_name, pwd->pw_gid) < 0) { jail_warnx(j, "initgroups %s: %s", pwd->pw_name, strerror(errno)); return -1; } return 0; } /* * Make sure a mount or consolelog path is a valid absolute pathname * with no symlinks. */ static int check_path(struct cfjail *j, const char *pname, const char *path, int isfile, const char *umount_type) { struct stat st, mpst; struct statfs stfs; char *tpath, *p; const char *jailpath; size_t jplen; if (path[0] != '/') { jail_warnx(j, "%s: %s: not an absolute pathname", pname, path); return -1; } /* * Only check for symlinks in components below the jail's path, * since that's where the security risk lies. */ jailpath = string_param(j->intparams[KP_PATH]); if (jailpath == NULL) jailpath = ""; jplen = strlen(jailpath); if (!strncmp(path, jailpath, jplen) && path[jplen] == '/') { tpath = alloca(strlen(path) + 1); strcpy(tpath, path); for (p = tpath + jplen; p != NULL; ) { p = strchr(p + 1, '/'); if (p) *p = '\0'; if (lstat(tpath, &st) < 0) { if (errno == ENOENT && isfile && !p) break; jail_warnx(j, "%s: %s: %s", pname, tpath, strerror(errno)); return -1; } if (S_ISLNK(st.st_mode)) { jail_warnx(j, "%s: %s is a symbolic link", pname, tpath); return -1; } if (p) *p = '/'; } } if (umount_type != NULL) { if (stat(path, &st) < 0 || statfs(path, &stfs) < 0) { jail_warnx(j, "%s: %s: %s", pname, path, strerror(errno)); return -1; } if (stat(stfs.f_mntonname, &mpst) < 0) { jail_warnx(j, "%s: %s: %s", pname, stfs.f_mntonname, strerror(errno)); return -1; } if (st.st_ino != mpst.st_ino) { jail_warnx(j, "%s: %s: not a mount point", pname, path); return -1; } if (strcmp(stfs.f_fstypename, umount_type)) { jail_warnx(j, "%s: %s: not a %s mount", pname, path, umount_type); return -1; } } return 0; } Index: head/usr.sbin/jail/jail.c =================================================================== --- head/usr.sbin/jail/jail.c (revision 275072) +++ head/usr.sbin/jail/jail.c (revision 275073) @@ -1,1016 +1,1016 @@ /*- * Copyright (c) 1999 Poul-Henning Kamp. * Copyright (c) 2009-2012 James Gritton * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include "jailp.h" #define JP_RDTUN(jp) (((jp)->jp_ctltype & CTLFLAG_RDTUN) == CTLFLAG_RDTUN) struct permspec { const char *name; enum intparam ipnum; int rev; }; const char *cfname; int iflag; int note_remove; int verbose; static void clear_persist(struct cfjail *j); static int update_jail(struct cfjail *j); static int rdtun_params(struct cfjail *j, int dofail); static void running_jid(struct cfjail *j, int dflag); static void jail_quoted_warnx(const struct cfjail *j, const char *name_msg, const char *noname_msg); static int jailparam_set_note(const struct cfjail *j, struct jailparam *jp, unsigned njp, int flags); static void print_jail(FILE *fp, struct cfjail *j, int oldcl); static void print_param(FILE *fp, const struct cfparam *p, int sep, int doname); static void quoted_print(FILE *fp, char *str); static void usage(void); static struct permspec perm_sysctl[] = { { "security.jail.set_hostname_allowed", KP_ALLOW_SET_HOSTNAME, 0 }, { "security.jail.sysvipc_allowed", KP_ALLOW_SYSVIPC, 0 }, { "security.jail.allow_raw_sockets", KP_ALLOW_RAW_SOCKETS, 0 }, { "security.jail.chflags_allowed", KP_ALLOW_CHFLAGS, 0 }, { "security.jail.mount_allowed", KP_ALLOW_MOUNT, 0 }, { "security.jail.socket_unixiproute_only", KP_ALLOW_SOCKET_AF, 1 }, }; static const enum intparam startcommands[] = { IP__NULL, #ifdef INET IP__IP4_IFADDR, #endif #ifdef INET6 IP__IP6_IFADDR, #endif IP_MOUNT, IP__MOUNT_FROM_FSTAB, IP_MOUNT_DEVFS, IP_MOUNT_FDESCFS, IP_EXEC_PRESTART, IP__OP, IP_VNET_INTERFACE, IP_EXEC_START, IP_COMMAND, IP_EXEC_POSTSTART, IP__NULL }; static const enum intparam stopcommands[] = { IP__NULL, IP_EXEC_PRESTOP, IP_EXEC_STOP, IP_STOP_TIMEOUT, IP__OP, IP_EXEC_POSTSTOP, IP_MOUNT_FDESCFS, IP_MOUNT_DEVFS, IP__MOUNT_FROM_FSTAB, IP_MOUNT, #ifdef INET6 IP__IP6_IFADDR, #endif #ifdef INET IP__IP4_IFADDR, #endif IP__NULL }; int main(int argc, char **argv) { struct stat st; FILE *jfp; struct cfjail *j; char *JidFile; size_t sysvallen; unsigned op, pi; int ch, docf, error, i, oldcl, sysval; int dflag, Rflag; char enforce_statfs[4]; #if defined(INET) || defined(INET6) char *cs, *ncs; #endif #if defined(INET) && defined(INET6) struct in6_addr addr6; #endif op = 0; dflag = Rflag = 0; docf = 1; cfname = CONF_FILE; JidFile = NULL; while ((ch = getopt(argc, argv, "cdf:hiJ:lmn:p:qrRs:u:U:v")) != -1) { switch (ch) { case 'c': op |= JF_START; break; case 'd': dflag = 1; break; case 'f': cfname = optarg; break; case 'h': #if defined(INET) || defined(INET6) add_param(NULL, NULL, IP_IP_HOSTNAME, NULL); #endif docf = 0; break; case 'i': iflag = 1; verbose = -1; break; case 'J': JidFile = optarg; break; case 'l': add_param(NULL, NULL, IP_EXEC_CLEAN, NULL); docf = 0; break; case 'm': op |= JF_SET; break; case 'n': add_param(NULL, NULL, KP_NAME, optarg); docf = 0; break; case 'p': paralimit = strtol(optarg, NULL, 10); if (paralimit == 0) paralimit = -1; break; case 'q': verbose = -1; break; case 'r': op |= JF_STOP; break; case 'R': op |= JF_STOP; Rflag = 1; break; case 's': add_param(NULL, NULL, KP_SECURELEVEL, optarg); docf = 0; break; case 'u': add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg); add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER, NULL); docf = 0; break; case 'U': add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg); add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER, "false"); docf = 0; break; case 'v': verbose = 1; break; default: usage(); } } argc -= optind; argv += optind; /* Find out which of the four command line styles this is. */ oldcl = 0; if (!op) { /* Old-style command line with four fixed parameters */ if (argc < 4 || argv[0][0] != '/') usage(); op = JF_START; docf = 0; oldcl = 1; add_param(NULL, NULL, KP_PATH, argv[0]); add_param(NULL, NULL, KP_HOST_HOSTNAME, argv[1]); #if defined(INET) || defined(INET6) if (argv[2][0] != '\0') { for (cs = argv[2];; cs = ncs + 1) { ncs = strchr(cs, ','); if (ncs) *ncs = '\0'; add_param(NULL, NULL, #if defined(INET) && defined(INET6) inet_pton(AF_INET6, cs, &addr6) == 1 ? KP_IP6_ADDR : KP_IP4_ADDR, #elif defined(INET) KP_IP4_ADDR, #elif defined(INET6) KP_IP6_ADDR, #endif cs); if (!ncs) break; } } #endif for (i = 3; i < argc; i++) add_param(NULL, NULL, IP_COMMAND, argv[i]); /* Emulate the defaults from security.jail.* sysctls. */ sysvallen = sizeof(sysval); if (sysctlbyname("security.jail.jailed", &sysval, &sysvallen, NULL, 0) == 0 && sysval == 0) { for (pi = 0; pi < sizeof(perm_sysctl) / sizeof(perm_sysctl[0]); pi++) { sysvallen = sizeof(sysval); if (sysctlbyname(perm_sysctl[pi].name, &sysval, &sysvallen, NULL, 0) == 0) add_param(NULL, NULL, perm_sysctl[pi].ipnum, (sysval ? 1 : 0) ^ perm_sysctl[pi].rev ? NULL : "false"); } sysvallen = sizeof(sysval); if (sysctlbyname("security.jail.enforce_statfs", &sysval, &sysvallen, NULL, 0) == 0) { snprintf(enforce_statfs, sizeof(enforce_statfs), "%d", sysval); add_param(NULL, NULL, KP_ENFORCE_STATFS, enforce_statfs); } } } else if (op == JF_STOP) { /* Jail remove, perhaps using the config file */ if (!docf || argc == 0) usage(); if (!Rflag) for (i = 0; i < argc; i++) if (strchr(argv[i], '=')) usage(); if ((docf = !Rflag && (!strcmp(cfname, "-") || stat(cfname, &st) == 0))) load_config(); note_remove = docf || argc > 1 || wild_jail_name(argv[0]); } else if (argc > 1 || (argc == 1 && strchr(argv[0], '='))) { /* Single jail specified on the command line */ if (Rflag) usage(); docf = 0; for (i = 0; i < argc; i++) { if (!strncmp(argv[i], "command", 7) && (argv[i][7] == '\0' || argv[i][7] == '=')) { if (argv[i][7] == '=') add_param(NULL, NULL, IP_COMMAND, argv[i] + 8); for (i++; i < argc; i++) add_param(NULL, NULL, IP_COMMAND, argv[i]); } #ifdef INET else if (!strncmp(argv[i], "ip4.addr=", 9)) { for (cs = argv[i] + 9;; cs = ncs + 1) { ncs = strchr(cs, ','); if (ncs) *ncs = '\0'; add_param(NULL, NULL, KP_IP4_ADDR, cs); if (!ncs) break; } } #endif #ifdef INET6 else if (!strncmp(argv[i], "ip6.addr=", 9)) { for (cs = argv[i] + 9;; cs = ncs + 1) { ncs = strchr(cs, ','); if (ncs) *ncs = '\0'; add_param(NULL, NULL, KP_IP6_ADDR, cs); if (!ncs) break; } } #endif else add_param(NULL, NULL, 0, argv[i]); } } else { /* From the config file, perhaps with a specified jail */ if (Rflag || !docf) usage(); load_config(); } /* Find out which jails will be run. */ dep_setup(docf); error = 0; if (op == JF_STOP) { for (i = 0; i < argc; i++) if (start_state(argv[i], docf, op, Rflag) < 0) error = 1; } else { if (start_state(argv[0], docf, op, 0) < 0) exit(1); } jfp = NULL; if (JidFile != NULL) { jfp = fopen(JidFile, "w"); if (jfp == NULL) err(1, "open %s", JidFile); setlinebuf(jfp); } setlinebuf(stdout); /* * The main loop: Get an available jail and perform the required * operation on it. When that is done, the jail may be finished, * or it may go back for the next step. */ while ((j = next_jail())) { if (j->flags & JF_FAILED) { error = 1; if (j->comparam == NULL) { dep_done(j, 0); continue; } } if (!(j->flags & JF_PARAMS)) { j->flags |= JF_PARAMS; if (dflag) add_param(j, NULL, IP_ALLOW_DYING, NULL); if (check_intparams(j) < 0) continue; if ((j->flags & (JF_START | JF_SET)) && import_params(j) < 0) continue; } if (!j->jid) running_jid(j, (j->flags & (JF_SET | JF_DEPEND)) == JF_SET ? dflag || bool_param(j->intparams[IP_ALLOW_DYING]) : 0); if (finish_command(j)) continue; switch (j->flags & JF_OP_MASK) { /* * These operations just turn into a different op * depending on the jail's current status. */ case JF_START_SET: j->flags = j->jid < 0 ? JF_START : JF_SET; break; case JF_SET_RESTART: if (j->jid < 0) { jail_quoted_warnx(j, "not found", "no jail specified"); failed(j); continue; } j->flags = rdtun_params(j, 0) ? JF_RESTART : JF_SET; if (j->flags == JF_RESTART) dep_reset(j); break; case JF_START_SET_RESTART: j->flags = j->jid < 0 ? JF_START : rdtun_params(j, 0) ? JF_RESTART : JF_SET; if (j->flags == JF_RESTART) dep_reset(j); } switch (j->flags & JF_OP_MASK) { case JF_START: if (j->comparam == NULL) { if (j->jid > 0 && !(j->flags & (JF_DEPEND | JF_WILD))) { jail_quoted_warnx(j, "already exists", NULL); failed(j); continue; } if (dep_check(j)) continue; if (j->jid > 0) goto jail_create_done; j->comparam = startcommands; j->comstring = NULL; } if (next_command(j)) continue; jail_create_done: clear_persist(j); if (jfp != NULL) print_jail(jfp, j, oldcl); dep_done(j, 0); break; case JF_SET: if (j->jid < 0 && !(j->flags & JF_DEPEND)) { jail_quoted_warnx(j, "not found", "no jail specified"); failed(j); continue; } if (dep_check(j)) continue; if (!(j->flags & JF_DEPEND)) { if (rdtun_params(j, 1) < 0 || update_jail(j) < 0) continue; if (verbose >= 0 && (j->name || verbose > 0)) jail_note(j, "updated\n"); } dep_done(j, 0); break; case JF_STOP: case JF_RESTART: if (j->comparam == NULL) { if (dep_check(j)) continue; if (j->jid < 0) { if (!(j->flags & (JF_DEPEND|JF_WILD))) { if (verbose >= 0) jail_quoted_warnx(j, "not found", NULL); failed(j); } goto jail_remove_done; } j->comparam = stopcommands; j->comstring = NULL; } else if ((j->flags & JF_FAILED) && j->jid > 0) goto jail_remove_done; if (next_command(j)) continue; jail_remove_done: dep_done(j, 0); if ((j->flags & (JF_START | JF_FAILED)) == JF_START) { j->comparam = NULL; j->flags &= ~JF_STOP; dep_reset(j); requeue(j, j->ndeps ? &depend : &ready); } break; } } if (jfp != NULL) fclose(jfp); exit(error); } /* * Mark a jail's failure for future handling. */ void failed(struct cfjail *j) { j->flags |= JF_FAILED; TAILQ_REMOVE(j->queue, j, tq); TAILQ_INSERT_HEAD(&ready, j, tq); j->queue = &ready; } /* * Exit slightly more gracefully when out of memory. */ void * emalloc(size_t size) { void *p; p = malloc(size); if (!p) err(1, "malloc"); return p; } void * erealloc(void *ptr, size_t size) { void *p; p = realloc(ptr, size); if (!p) err(1, "malloc"); return p; } char * estrdup(const char *str) { char *ns; ns = strdup(str); if (!ns) err(1, "malloc"); return ns; } /* * Print a message including an optional jail name. */ void jail_note(const struct cfjail *j, const char *fmt, ...) { va_list ap, tap; char *cs; size_t len; va_start(ap, fmt); va_copy(tap, ap); len = vsnprintf(NULL, 0, fmt, tap); va_end(tap); cs = alloca(len + 1); (void)vsnprintf(cs, len + 1, fmt, ap); va_end(ap); if (j->name) printf("%s: %s", j->name, cs); else printf("%s", cs); } /* * Print a warning message including an optional jail name. */ void jail_warnx(const struct cfjail *j, const char *fmt, ...) { va_list ap, tap; char *cs; size_t len; va_start(ap, fmt); va_copy(tap, ap); len = vsnprintf(NULL, 0, fmt, tap); va_end(tap); cs = alloca(len + 1); (void)vsnprintf(cs, len + 1, fmt, ap); va_end(ap); if (j->name) warnx("%s: %s", j->name, cs); else warnx("%s", cs); } /* * Create a new jail. */ int create_jail(struct cfjail *j) { struct iovec jiov[4]; struct stat st; struct jailparam *jp, *setparams, *setparams2, *sjp; const char *path; int dopersist, ns, jid, dying, didfail; /* * Check the jail's path, with a better error message than jail_set * gives. */ if ((path = string_param(j->intparams[KP_PATH]))) { if (j->name != NULL && path[0] != '/') { jail_warnx(j, "path %s: not an absolute pathname", path); return -1; } if (stat(path, &st) < 0) { jail_warnx(j, "path %s: %s", path, strerror(errno)); return -1; } if (!S_ISDIR(st.st_mode)) { jail_warnx(j, "path %s: %s", path, strerror(ENOTDIR)); return -1; } } /* * Copy all the parameters, except that "persist" is always set when * there are commands to run later. */ dopersist = !bool_param(j->intparams[KP_PERSIST]) && (j->intparams[IP_EXEC_START] || j->intparams[IP_COMMAND] || j->intparams[IP_EXEC_POSTSTART]); sjp = setparams = alloca((j->njp + dopersist) * sizeof(struct jailparam)); if (dopersist && jailparam_init(sjp++, "persist") < 0) { jail_warnx(j, "%s", jail_errmsg); return -1; } for (jp = j->jp; jp < j->jp + j->njp; jp++) if (!dopersist || !equalopts(jp->jp_name, "persist")) *sjp++ = *jp; ns = sjp - setparams; didfail = 0; j->jid = jailparam_set_note(j, setparams, ns, JAIL_CREATE); if (j->jid < 0 && errno == EEXIST && bool_param(j->intparams[IP_ALLOW_DYING]) && int_param(j->intparams[KP_JID], &jid) && jid != 0) { /* * The jail already exists, but may be dying. * Make sure it is, in which case an update is appropriate. */ - *(const void **)&jiov[0].iov_base = "jid"; + jiov[0].iov_base = __DECONST(char *, "jid"); jiov[0].iov_len = sizeof("jid"); jiov[1].iov_base = &jid; jiov[1].iov_len = sizeof(jid); - *(const void **)&jiov[2].iov_base = "dying"; + jiov[2].iov_base = __DECONST(char *, "dying"); jiov[2].iov_len = sizeof("dying"); jiov[3].iov_base = &dying; jiov[3].iov_len = sizeof(dying); if (jail_get(jiov, 4, JAIL_DYING) < 0) { /* * It could be that the jail just barely finished * dying, or it could be that the jid never existed * but the name does. In either case, another try * at creating the jail should do the right thing. */ if (errno == ENOENT) j->jid = jailparam_set_note(j, setparams, ns, JAIL_CREATE); } else if (dying) { j->jid = jid; if (rdtun_params(j, 1) < 0) { j->jid = -1; didfail = 1; } else { sjp = setparams2 = alloca((j->njp + dopersist) * sizeof(struct jailparam)); for (jp = setparams; jp < setparams + ns; jp++) if (!JP_RDTUN(jp) || !strcmp(jp->jp_name, "jid")) *sjp++ = *jp; j->jid = jailparam_set_note(j, setparams2, sjp - setparams2, JAIL_UPDATE | JAIL_DYING); /* * Again, perhaps the jail just finished dying. */ if (j->jid < 0 && errno == ENOENT) j->jid = jailparam_set_note(j, setparams, ns, JAIL_CREATE); } } } if (j->jid < 0 && !didfail) { jail_warnx(j, "%s", jail_errmsg); failed(j); } if (dopersist) { jailparam_free(setparams, 1); if (j->jid > 0) j->flags |= JF_PERSIST; } return j->jid; } /* * Remove a temporarily set "persist" parameter. */ static void clear_persist(struct cfjail *j) { struct iovec jiov[4]; int jid; if (!(j->flags & JF_PERSIST)) return; j->flags &= ~JF_PERSIST; - *(const void **)&jiov[0].iov_base = "jid"; + jiov[0].iov_base = __DECONST(char *, "jid"); jiov[0].iov_len = sizeof("jid"); jiov[1].iov_base = &j->jid; jiov[1].iov_len = sizeof(j->jid); - *(const void **)&jiov[2].iov_base = "nopersist"; + jiov[2].iov_base = __DECONST(char *, "nopersist"); jiov[2].iov_len = sizeof("nopersist"); jiov[3].iov_base = NULL; jiov[3].iov_len = 0; jid = jail_set(jiov, 4, JAIL_UPDATE); if (verbose > 0) jail_note(j, "jail_set(JAIL_UPDATE) jid=%d nopersist%s%s\n", j->jid, jid < 0 ? ": " : "", jid < 0 ? strerror(errno) : ""); } /* * Set a jail's parameters. */ static int update_jail(struct cfjail *j) { struct jailparam *jp, *setparams, *sjp; int ns, jid; ns = 0; for (jp = j->jp; jp < j->jp + j->njp; jp++) if (!JP_RDTUN(jp)) ns++; if (ns == 0) return 0; sjp = setparams = alloca(++ns * sizeof(struct jailparam)); if (jailparam_init(sjp, "jid") < 0 || jailparam_import_raw(sjp, &j->jid, sizeof j->jid) < 0) { jail_warnx(j, "%s", jail_errmsg); failed(j); return -1; } for (jp = j->jp; jp < j->jp + j->njp; jp++) if (!JP_RDTUN(jp)) *++sjp = *jp; jid = jailparam_set_note(j, setparams, ns, bool_param(j->intparams[IP_ALLOW_DYING]) ? JAIL_UPDATE | JAIL_DYING : JAIL_UPDATE); if (jid < 0) { jail_warnx(j, "%s", jail_errmsg); failed(j); } jailparam_free(setparams, 1); return jid; } /* * Return if a jail set would change any create-only parameters. */ static int rdtun_params(struct cfjail *j, int dofail) { struct jailparam *jp, *rtparams, *rtjp; int nrt, rval; if (j->flags & JF_RDTUN) return 0; j->flags |= JF_RDTUN; nrt = 0; for (jp = j->jp; jp < j->jp + j->njp; jp++) if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) nrt++; if (nrt == 0) return 0; rtjp = rtparams = alloca(++nrt * sizeof(struct jailparam)); if (jailparam_init(rtjp, "jid") < 0 || jailparam_import_raw(rtjp, &j->jid, sizeof j->jid) < 0) { jail_warnx(j, "%s", jail_errmsg); exit(1); } for (jp = j->jp; jp < j->jp + j->njp; jp++) if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) *++rtjp = *jp; rval = 0; if (jailparam_get(rtparams, nrt, bool_param(j->intparams[IP_ALLOW_DYING]) ? JAIL_DYING : 0) > 0) { rtjp = rtparams + 1; for (jp = j->jp, rtjp = rtparams + 1; rtjp < rtparams + nrt; jp++) { if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) { if (!((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) && jp->jp_valuelen == 0 && *(int *)jp->jp_value) && !(rtjp->jp_valuelen == jp->jp_valuelen && !memcmp(rtjp->jp_value, jp->jp_value, jp->jp_valuelen))) { if (dofail) { jail_warnx(j, "%s cannot be " "changed after creation", jp->jp_name); failed(j); rval = -1; } else rval = 1; break; } rtjp++; } } } for (rtjp = rtparams + 1; rtjp < rtparams + nrt; rtjp++) rtjp->jp_name = NULL; jailparam_free(rtparams, nrt); return rval; } /* * Get the jail's jid if it is running. */ static void running_jid(struct cfjail *j, int dflag) { struct iovec jiov[2]; const char *pval; char *ep; int jid; if ((pval = string_param(j->intparams[KP_JID]))) { if (!(jid = strtol(pval, &ep, 10)) || *ep) { j->jid = -1; return; } - *(const void **)&jiov[0].iov_base = "jid"; + jiov[0].iov_base = __DECONST(char *, "jid"); jiov[0].iov_len = sizeof("jid"); jiov[1].iov_base = &jid; jiov[1].iov_len = sizeof(jid); } else if ((pval = string_param(j->intparams[KP_NAME]))) { - *(const void **)&jiov[0].iov_base = "name"; + jiov[0].iov_base = __DECONST(char *, "name"); jiov[0].iov_len = sizeof("name"); jiov[1].iov_len = strlen(pval) + 1; jiov[1].iov_base = alloca(jiov[1].iov_len); strcpy(jiov[1].iov_base, pval); } else { j->jid = -1; return; } j->jid = jail_get(jiov, 2, dflag ? JAIL_DYING : 0); } static void jail_quoted_warnx(const struct cfjail *j, const char *name_msg, const char *noname_msg) { const char *pval; if ((pval = j->name) || (pval = string_param(j->intparams[KP_JID])) || (pval = string_param(j->intparams[KP_NAME]))) warnx("\"%s\" %s", pval, name_msg); else warnx("%s", noname_msg); } /* - * Set jail parameters and possible print them out. + * Set jail parameters and possibly print them out. */ static int jailparam_set_note(const struct cfjail *j, struct jailparam *jp, unsigned njp, int flags) { char *value; int jid; unsigned i; jid = jailparam_set(jp, njp, flags); if (verbose > 0) { jail_note(j, "jail_set(%s%s)", (flags & (JAIL_CREATE | JAIL_UPDATE)) == JAIL_CREATE ? "JAIL_CREATE" : "JAIL_UPDATE", (flags & JAIL_DYING) ? " | JAIL_DYING" : ""); for (i = 0; i < njp; i++) { printf(" %s", jp[i].jp_name); if (jp[i].jp_value == NULL) continue; putchar('='); value = jailparam_export(jp + i); if (value == NULL) err(1, "jailparam_export"); quoted_print(stdout, value); free(value); } if (jid < 0) printf(": %s", strerror(errno)); printf("\n"); } return jid; } /* * Print a jail record. */ static void print_jail(FILE *fp, struct cfjail *j, int oldcl) { struct cfparam *p; if (oldcl) { fprintf(fp, "%d\t", j->jid); print_param(fp, j->intparams[KP_PATH], ',', 0); putc('\t', fp); print_param(fp, j->intparams[KP_HOST_HOSTNAME], ',', 0); putc('\t', fp); #ifdef INET print_param(fp, j->intparams[KP_IP4_ADDR], ',', 0); #ifdef INET6 if (j->intparams[KP_IP4_ADDR] && !TAILQ_EMPTY(&j->intparams[KP_IP4_ADDR]->val) && j->intparams[KP_IP6_ADDR] && !TAILQ_EMPTY(&j->intparams[KP_IP6_ADDR]->val)) putc(',', fp); #endif #endif #ifdef INET6 print_param(fp, j->intparams[KP_IP6_ADDR], ',', 0); #endif putc('\t', fp); print_param(fp, j->intparams[IP_COMMAND], ' ', 0); } else { fprintf(fp, "jid=%d", j->jid); TAILQ_FOREACH(p, &j->params, tq) if (strcmp(p->name, "jid")) { putc(' ', fp); print_param(fp, p, ',', 1); } } putc('\n', fp); } /* * Print a parameter value, or a name=value pair. */ static void print_param(FILE *fp, const struct cfparam *p, int sep, int doname) { const struct cfstring *s, *ts; if (doname) fputs(p->name, fp); if (p == NULL || TAILQ_EMPTY(&p->val)) return; if (doname) putc('=', fp); TAILQ_FOREACH_SAFE(s, &p->val, tq, ts) { quoted_print(fp, s->s); if (ts != NULL) putc(sep, fp); } } /* * Print a string with quotes around spaces. */ static void quoted_print(FILE *fp, char *str) { int c, qc; char *p = str; qc = !*p ? '"' : strchr(p, '\'') ? '"' : strchr(p, '"') ? '\'' : strchr(p, ' ') || strchr(p, '\t') ? '"' : 0; if (qc) putc(qc, fp); while ((c = *p++)) { if (c == '\\' || c == qc) putc('\\', fp); putc(c, fp); } if (qc) putc(qc, fp); } static void usage(void) { (void)fprintf(stderr, "usage: jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n" " -[cmr] param=value ... [command=command ...]\n" " jail [-dqv] [-f file] -[cmr] [jail]\n" " jail [-qv] [-f file] -[rR] ['*' | jail ...]\n" " jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n" " [-n jailname] [-s securelevel]\n" " path hostname [ip[,...]] command ...\n"); exit(1); } Index: head/usr.sbin/jail/state.c =================================================================== --- head/usr.sbin/jail/state.c (revision 275072) +++ head/usr.sbin/jail/state.c (revision 275073) @@ -1,469 +1,468 @@ /*- * Copyright (c) 2011 James Gritton * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include "jailp.h" struct cfjails ready = TAILQ_HEAD_INITIALIZER(ready); struct cfjails depend = TAILQ_HEAD_INITIALIZER(depend); static void dep_add(struct cfjail *from, struct cfjail *to, unsigned flags); static int cmp_jailptr(const void *a, const void *b); static int cmp_jailptr_name(const void *a, const void *b); static struct cfjail *find_jail(const char *name); static int running_jid(const char *name, int flags); static struct cfjail **jails_byname; static size_t njails; /* * Set up jail dependency lists. */ void dep_setup(int docf) { struct cfjail *j, *dj; struct cfparam *p; struct cfstring *s; struct cfdepend *d; const char *cs; char *pname; size_t plen; - int error, deps, ldeps; + int deps, ldeps; if (!docf) { /* * With no config file, let "depend" for a single jail * look at currently running jails. */ if ((j = TAILQ_FIRST(&cfjails)) && (p = j->intparams[IP_DEPEND])) { TAILQ_FOREACH(s, &p->val, tq) { if (running_jid(s->s, 0) < 0) { warnx("depends on nonexistent jail " "\"%s\"", s->s); j->flags |= JF_FAILED; } } } return; } njails = 0; TAILQ_FOREACH(j, &cfjails, tq) njails++; jails_byname = emalloc(njails * sizeof(struct cfjail *)); njails = 0; TAILQ_FOREACH(j, &cfjails, tq) jails_byname[njails++] = j; qsort(jails_byname, njails, sizeof(struct cfjail *), cmp_jailptr); - error = 0; deps = 0; ldeps = 0; plen = 0; pname = NULL; TAILQ_FOREACH(j, &cfjails, tq) { if (j->flags & JF_FAILED) continue; if ((p = j->intparams[IP_DEPEND])) { TAILQ_FOREACH(s, &p->val, tq) { dj = find_jail(s->s); if (dj != NULL) { deps++; dep_add(j, dj, 0); } else { jail_warnx(j, "depends on undefined jail \"%s\"", s->s); j->flags |= JF_FAILED; } } } /* A jail has an implied dependency on its parent. */ if ((cs = strrchr(j->name, '.'))) { if (plen < (size_t)(cs - j->name + 1)) { plen = (cs - j->name) + 1; pname = erealloc(pname, plen); } strlcpy(pname, j->name, plen); dj = find_jail(pname); if (dj != NULL) { ldeps++; dep_add(j, dj, DF_LIGHT); } } } /* Look for dependency loops. */ if (deps && (deps > 1 || ldeps)) { (void)start_state(NULL, 0, 0, 0); while ((j = TAILQ_FIRST(&ready))) { requeue(j, &cfjails); dep_done(j, DF_NOFAIL); } while ((j = TAILQ_FIRST(&depend)) != NULL) { jail_warnx(j, "dependency loop"); j->flags |= JF_FAILED; do { requeue(j, &cfjails); dep_done(j, DF_NOFAIL); } while ((j = TAILQ_FIRST(&ready))); } TAILQ_FOREACH(j, &cfjails, tq) STAILQ_FOREACH(d, &j->dep[DEP_FROM], tq[DEP_FROM]) d->flags &= ~DF_SEEN; } if (pname != NULL) free(pname); } /* * Return if a jail has dependencies. */ int dep_check(struct cfjail *j) { int reset, depfrom, depto, ndeps, rev; struct cfjail *dj; struct cfdepend *d; static int bits[] = { 0, 1, 1, 2, 1, 2, 2, 3 }; if (j->ndeps == 0) return 0; ndeps = 0; if ((rev = JF_DO_STOP(j->flags))) { depfrom = DEP_TO; depto = DEP_FROM; } else { depfrom = DEP_FROM; depto = DEP_TO; } STAILQ_FOREACH(d, &j->dep[depfrom], tq[depfrom]) { if (d->flags & DF_SEEN) continue; dj = d->j[depto]; if (dj->flags & JF_FAILED) { if (!(j->flags & (JF_DEPEND | JF_FAILED)) && verbose >= 0) jail_warnx(j, "skipped"); j->flags |= JF_FAILED; continue; } /* * The dependee's state may be set (or changed) as a result of * being in a dependency it wasn't in earlier. */ reset = 0; if (bits[dj->flags & JF_OP_MASK] <= 1) { if (!(dj->flags & JF_OP_MASK)) { reset = 1; dj->flags |= JF_DEPEND; requeue(dj, &ready); } /* Set or change the dependee's state. */ switch (j->flags & JF_OP_MASK) { case JF_START: dj->flags |= JF_START; break; case JF_SET: if (!(dj->flags & JF_OP_MASK)) dj->flags |= JF_SET; else if (dj->flags & JF_STOP) dj->flags |= JF_START; break; case JF_STOP: case JF_RESTART: if (!(dj->flags & JF_STOP)) reset = 1; dj->flags |= JF_STOP; if (dj->flags & JF_SET) dj->flags ^= (JF_START | JF_SET); break; } } if (reset) dep_reset(dj); if (!((d->flags & DF_LIGHT) && (rev ? dj->jid < 0 : dj->jid > 0))) ndeps++; } if (ndeps == 0) return 0; requeue(j, &depend); return 1; } /* * Resolve any dependencies from a finished jail. */ void dep_done(struct cfjail *j, unsigned flags) { struct cfjail *dj; struct cfdepend *d; int depfrom, depto; if (JF_DO_STOP(j->flags)) { depfrom = DEP_TO; depto = DEP_FROM; } else { depfrom = DEP_FROM; depto = DEP_TO; } STAILQ_FOREACH(d, &j->dep[depto], tq[depto]) { if ((d->flags & DF_SEEN) | (flags & ~d->flags & DF_LIGHT)) continue; d->flags |= DF_SEEN; dj = d->j[depfrom]; if (!(flags & DF_NOFAIL) && (j->flags & JF_FAILED) && (j->flags & (JF_OP_MASK | JF_DEPEND)) != (JF_SET | JF_DEPEND)) { if (!(dj->flags & (JF_DEPEND | JF_FAILED)) && verbose >= 0) jail_warnx(dj, "skipped"); dj->flags |= JF_FAILED; } if (!--dj->ndeps && dj->queue == &depend) requeue(dj, &ready); } } /* * Count a jail's dependencies and mark them as unseen. */ void dep_reset(struct cfjail *j) { int depfrom; struct cfdepend *d; depfrom = JF_DO_STOP(j->flags) ? DEP_TO : DEP_FROM; j->ndeps = 0; STAILQ_FOREACH(d, &j->dep[depfrom], tq[depfrom]) j->ndeps++; } /* * Find the next jail ready to do something. */ struct cfjail * next_jail(void) { struct cfjail *j; if (!(j = next_proc(!TAILQ_EMPTY(&ready))) && (j = TAILQ_FIRST(&ready)) && JF_DO_STOP(j->flags) && (j = TAILQ_LAST(&ready, cfjails)) && !JF_DO_STOP(j->flags)) { TAILQ_FOREACH_REVERSE(j, &ready, cfjails, tq) if (JF_DO_STOP(j->flags)) break; } if (j != NULL) requeue(j, &cfjails); return j; } /* * Set jails to the proper start state. */ int start_state(const char *target, int docf, unsigned state, int running) { struct iovec jiov[6]; struct cfjail *j, *tj; int jid; char namebuf[MAXHOSTNAMELEN]; if (!target || (!docf && state != JF_STOP) || (!running && !strcmp(target, "*"))) { /* * For a global wildcard (including no target specified), * set the state on all jails and start with those that * have no dependencies. */ TAILQ_FOREACH_SAFE(j, &cfjails, tq, tj) { j->flags = (j->flags & JF_FAILED) | state | (docf ? JF_WILD : 0); dep_reset(j); requeue(j, j->ndeps ? &depend : &ready); } } else if (wild_jail_name(target)) { /* * For targets specified singly, or with a non-global wildcard, * set their state and call them ready (even if there are * dependencies). Leave everything else unqueued for now. */ if (running) { /* * -R matches its wildcards against currently running * jails, not against the config file. */ - *(const void **)&jiov[0].iov_base = "lastjid"; + jiov[0].iov_base = __DECONST(char *, "lastjid"); jiov[0].iov_len = sizeof("lastjid"); jiov[1].iov_base = &jid; jiov[1].iov_len = sizeof(jid); - *(const void **)&jiov[2].iov_base = "jid"; + jiov[2].iov_base = __DECONST(char *, "jid"); jiov[2].iov_len = sizeof("jid"); jiov[3].iov_base = &jid; jiov[3].iov_len = sizeof(jid); - *(const void **)&jiov[4].iov_base = "name"; + jiov[4].iov_base = __DECONST(char *, "name"); jiov[4].iov_len = sizeof("name"); jiov[5].iov_base = &namebuf; jiov[5].iov_len = sizeof(namebuf); for (jid = 0; jail_get(jiov, 6, 0) > 0; ) { if (wild_jail_match(namebuf, target)) { j = add_jail(); j->name = estrdup(namebuf); j->jid = jid; j->flags = (j->flags & JF_FAILED) | state | JF_WILD; dep_reset(j); requeue(j, &ready); } } } else { TAILQ_FOREACH_SAFE(j, &cfjails, tq, tj) { if (wild_jail_match(j->name, target)) { j->flags = (j->flags & JF_FAILED) | state | JF_WILD; dep_reset(j); requeue(j, &ready); } } } } else { j = find_jail(target); if (j == NULL && state == JF_STOP) { /* Allow -[rR] to specify a currently running jail. */ if ((jid = running_jid(target, JAIL_DYING)) > 0) { j = add_jail(); j->name = estrdup(target); j->jid = jid; } } if (j == NULL) { warnx("\"%s\" not found", target); return -1; } j->flags = (j->flags & JF_FAILED) | state; dep_reset(j); requeue(j, &ready); } return 0; } /* * Move a jail to a new list. */ void requeue(struct cfjail *j, struct cfjails *queue) { if (j->queue != queue) { TAILQ_REMOVE(j->queue, j, tq); TAILQ_INSERT_TAIL(queue, j, tq); j->queue = queue; } } /* * Add a dependency edge between two jails. */ static void dep_add(struct cfjail *from, struct cfjail *to, unsigned flags) { struct cfdepend *d; d = emalloc(sizeof(struct cfdepend)); d->flags = flags; d->j[DEP_FROM] = from; d->j[DEP_TO] = to; STAILQ_INSERT_TAIL(&from->dep[DEP_FROM], d, tq[DEP_FROM]); STAILQ_INSERT_TAIL(&to->dep[DEP_TO], d, tq[DEP_TO]); } /* * Compare jail pointers for qsort/bsearch. */ static int cmp_jailptr(const void *a, const void *b) { return strcmp((*((struct cfjail * const *)a))->name, ((*(struct cfjail * const *)b))->name); } static int cmp_jailptr_name(const void *a, const void *b) { return strcmp((const char *)a, ((*(struct cfjail * const *)b))->name); } /* * Find a jail object by name. */ static struct cfjail * find_jail(const char *name) { struct cfjail **jp; jp = bsearch(name, jails_byname, njails, sizeof(struct cfjail *), cmp_jailptr_name); return jp ? *jp : NULL; } /* * Return the named jail's jid if it is running, and -1 if it isn't. */ static int running_jid(const char *name, int flags) { struct iovec jiov[2]; char *ep; int jid; if ((jid = strtol(name, &ep, 10)) && !*ep) { - *(const void **)&jiov[0].iov_base = "jid"; + jiov[0].iov_base = __DECONST(char *, "jid"); jiov[0].iov_len = sizeof("jid"); jiov[1].iov_base = &jid; jiov[1].iov_len = sizeof(jid); } else { - *(const void **)&jiov[0].iov_base = "name"; + jiov[0].iov_base = __DECONST(char *, "name"); jiov[0].iov_len = sizeof("name"); jiov[1].iov_len = strlen(name) + 1; jiov[1].iov_base = alloca(jiov[1].iov_len); strcpy(jiov[1].iov_base, name); } return jail_get(jiov, 2, flags); }