int
cap_grp_limit_groups(cap_channel_t *chan, const char * const *names,
size_t nnames, gid_t *gids, size_t ngids)
{
nvlist_t *limits, *groups;
unsigned int i;
char nvlname[64];
int n;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL) {
limits = nvlist_create(0);
} else {
if (nvlist_exists_nvlist(limits, "groups"))
nvlist_free_nvlist(limits, "groups");
}
groups = nvlist_create(0);
for (i = 0; i < ngids; i++) {
n = snprintf(nvlname, sizeof(nvlname), "gid%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_number(groups, nvlname, (uint64_t)gids[i]);
}
for (i = 0; i < nnames; i++) {
n = snprintf(nvlname, sizeof(nvlname), "gid%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_string(groups, nvlname, names[i]);
}
nvlist_move_nvlist(limits, "groups", groups);
return (cap_limit_set(chan, limits));
}
int
cap_pwd_limit_users(cap_channel_t *chan, const char * const *names,
size_t nnames, uid_t *uids, size_t nuids)
{
nvlist_t *limits, *users;
char nvlname[64];
unsigned int i;
int n;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL) {
limits = nvlist_create(0);
} else {
if (nvlist_exists_nvlist(limits, "users"))
nvlist_free_nvlist(limits, "users");
}
users = nvlist_create(0);
for (i = 0; i < nuids; i++) {
n = snprintf(nvlname, sizeof(nvlname), "uid%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_number(users, nvlname, (uint64_t)uids[i]);
}
for (i = 0; i < nnames; i++) {
n = snprintf(nvlname, sizeof(nvlname), "name%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_string(users, nvlname, names[i]);
}
nvlist_move_nvlist(limits, "users", users);
return (cap_limit_set(chan, limits));
}
nvlist_t *
nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
{
const unsigned char *ptr;
nvlist_t *nvl;
nvpair_t *nvp;
size_t left;
int flags;
left = size;
ptr = buf;
nvl = nvlist_create(0);
if (nvl == NULL)
goto failed;
ptr = nvlist_unpack_header(nvl, ptr, nfds, &flags, &left);
if (ptr == NULL)
goto failed;
while (left > 0) {
ptr = nvpair_unpack(flags, ptr, &left, fds, nfds, &nvp);
if (ptr == NULL)
goto failed;
nvlist_move_nvpair(nvl, nvp);
}
return (nvl);
failed:
nvlist_destroy(nvl);
return (NULL);
}
int
u_sysctlbyname(int ns,
const char *name,
void *oldp,
size_t *oldlenp,
const void *newp,
size_t newlen)
{
nvlist_t *nvl = NULL;
int retval = 0;
/* Create nvlist to populate the request into */
nvl = nvlist_create(0);
if (nvl == NULL) {
warn("nvlist_create");
retval = -1;
goto done;
}
/* Create nvlist for a sysctl_str request */
nvlist_add_string(nvl, "type", "sysctl_str");
nvlist_add_string(nvl, "sysctl_str", name);
/* XXX this sets errno as appropriate */
retval = u_sysctl_do_sysctl(nvl, ns, oldp, oldlenp, newp, newlen);
done:
if (nvl)
nvlist_destroy(nvl);
return (retval);
}
int
cap_getnameinfo(cap_channel_t *chan, const struct sockaddr *sa, socklen_t salen,
char *host, size_t hostlen, char *serv, size_t servlen, int flags)
{
nvlist_t *nvl;
int error;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "getnameinfo");
nvlist_add_number(nvl, "hostlen", (uint64_t)hostlen);
nvlist_add_number(nvl, "servlen", (uint64_t)servlen);
nvlist_add_binary(nvl, "sa", sa, (size_t)salen);
nvlist_add_number(nvl, "flags", (uint64_t)flags);
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL)
return (EAI_MEMORY);
if (nvlist_get_number(nvl, "error") != 0) {
error = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (error);
}
if (host != NULL)
strlcpy(host, nvlist_get_string(nvl, "host"), hostlen + 1);
if (serv != NULL)
strlcpy(serv, nvlist_get_string(nvl, "serv"), servlen + 1);
nvlist_destroy(nvl);
return (0);
}
struct hostent *
cap_gethostbyaddr(cap_channel_t *chan, const void *addr, socklen_t len,
int type)
{
struct hostent *hp;
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "gethostbyaddr");
nvlist_add_binary(nvl, "addr", addr, (size_t)len);
nvlist_add_number(nvl, "family", (uint64_t)type);
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL) {
h_errno = NO_RECOVERY;
return (NULL);
}
if (nvlist_get_number(nvl, "error") != 0) {
h_errno = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (NULL);
}
hp = hostent_unpack(nvl, &hent);
nvlist_destroy(nvl);
return (hp);
}
struct hostent *
cap_gethostbyname2(cap_channel_t *chan, const char *name, int type)
{
struct hostent *hp;
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "gethostbyname");
nvlist_add_number(nvl, "family", (uint64_t)type);
nvlist_add_string(nvl, "name", name);
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL) {
h_errno = NO_RECOVERY;
return (NULL);
}
if (nvlist_get_number(nvl, "error") != 0) {
h_errno = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (NULL);
}
hp = hostent_unpack(nvl, &hent);
nvlist_destroy(nvl);
return (hp);
}
int
zygote_clone(zygote_func_t *func, int flags, int *chanfdp, int *procfdp)
{
nvlist_t *nvl;
int error;
if (zygote_sock == -1) {
/* Zygote didn't start. */
errno = ENXIO;
return (-1);
}
nvl = nvlist_create(0);
nvlist_add_number(nvl, "func", (uint64_t)(uintptr_t)func);
nvlist_add_number(nvl, "flags", (uint64_t)flags);
nvl = nvlist_xfer(zygote_sock, nvl);
if (nvl == NULL)
return (-1);
if (nvlist_exists_number(nvl, "error")) {
error = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
errno = error;
return (-1);
}
*chanfdp = nvlist_take_descriptor(nvl, "chanfd");
*procfdp = nvlist_take_descriptor(nvl, "procfd");
nvlist_destroy(nvl);
return (0);
}
nvlist_t *
nvlist_clone(const nvlist_t *nvl)
{
nvlist_t *newnvl;
nvpair_t *nvp, *newnvp;
NVLIST_ASSERT(nvl);
if (nvl->nvl_error != 0) {
ERRNO_SET(nvl->nvl_error);
return (NULL);
}
newnvl = nvlist_create(nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
nvp = nvlist_next_nvpair(nvl, nvp)) {
newnvp = nvpair_clone(nvp);
if (newnvp == NULL)
break;
nvlist_move_nvpair(newnvl, newnvp);
}
if (nvp != NULL) {
nvlist_destroy(newnvl);
return (NULL);
}
return (newnvl);
}
static void
child(int sock)
{
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_bool(nvl, "nvlist/bool/true", true);
nvlist_add_bool(nvl, "nvlist/bool/false", false);
nvlist_add_number(nvl, "nvlist/number/0", 0);
nvlist_add_number(nvl, "nvlist/number/1", 1);
nvlist_add_number(nvl, "nvlist/number/-1", -1);
nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
nvlist_add_string(nvl, "nvlist/string/", "");
nvlist_add_string(nvl, "nvlist/string/x", "x");
nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
nvlist_send(sock, nvl);
nvlist_destroy(nvl);
}
int
cap_getaddrinfo(cap_channel_t *chan, const char *hostname, const char *servname,
const struct addrinfo *hints, struct addrinfo **res)
{
struct addrinfo *firstai, *prevai, *curai;
unsigned int ii;
const nvlist_t *nvlai;
nvlist_t *nvl;
int error;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "getaddrinfo");
nvlist_add_string(nvl, "hostname", hostname);
nvlist_add_string(nvl, "servname", servname);
if (hints != NULL) {
nvlist_add_number(nvl, "hints.ai_flags",
(uint64_t)hints->ai_flags);
nvlist_add_number(nvl, "hints.ai_family",
(uint64_t)hints->ai_family);
nvlist_add_number(nvl, "hints.ai_socktype",
(uint64_t)hints->ai_socktype);
nvlist_add_number(nvl, "hints.ai_protocol",
(uint64_t)hints->ai_protocol);
}
nvl = cap_xfer_nvlist(chan, nvl);
if (nvl == NULL)
return (EAI_MEMORY);
if (nvlist_get_number(nvl, "error") != 0) {
error = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (error);
}
nvlai = NULL;
firstai = prevai = curai = NULL;
for (ii = 0; ; ii++) {
if (!nvlist_existsf_nvlist(nvl, "res%u", ii))
break;
nvlai = nvlist_getf_nvlist(nvl, "res%u", ii);
curai = addrinfo_unpack(nvlai);
if (curai == NULL)
break;
if (prevai != NULL)
prevai->ai_next = curai;
else if (firstai == NULL)
firstai = curai;
prevai = curai;
}
nvlist_destroy(nvl);
if (curai == NULL && nvlai != NULL) {
if (firstai == NULL)
freeaddrinfo(firstai);
return (EAI_MEMORY);
}
*res = firstai;
return (0);
}
static void
cap_set_end_pwent(cap_channel_t *chan, const char *cmd)
{
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", cmd);
/* Ignore any errors, we have no way to report them. */
nvlist_destroy(cap_xfer_nvlist(chan, nvl));
}
void
cap_endgrent(cap_channel_t *chan)
{
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "endgrent");
/* Ignore any errors, we have no way to report them. */
nvlist_destroy(cap_xfer_nvlist(chan, nvl, 0));
}
int
cap_grp_limit_cmds(cap_channel_t *chan, const char * const *cmds, size_t ncmds)
{
nvlist_t *limits, *nvl;
unsigned int i;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL) {
limits = nvlist_create(0);
} else {
if (nvlist_exists_nvlist(limits, "cmds"))
nvlist_free_nvlist(limits, "cmds");
}
nvl = nvlist_create(0);
for (i = 0; i < ncmds; i++)
nvlist_add_null(nvl, cmds[i]);
nvlist_move_nvlist(limits, "cmds", nvl);
return (cap_limit_set(chan, limits));
}
int
cap_pwd_limit_users(cap_channel_t *chan, const char * const *names,
size_t nnames, uid_t *uids, size_t nuids)
{
nvlist_t *limits, *users;
unsigned int i;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL) {
limits = nvlist_create(0);
} else {
if (nvlist_exists_nvlist(limits, "users"))
nvlist_free_nvlist(limits, "users");
}
users = nvlist_create(0);
for (i = 0; i < nuids; i++)
nvlist_addf_number(users, (uint64_t)uids[i], "uid%u", i);
for (i = 0; i < nnames; i++)
nvlist_addf_string(users, names[i], "name%u", i);
nvlist_move_nvlist(limits, "users", users);
return (cap_limit_set(chan, limits));
}
int
cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
size_t *oldlenp, const void *newp, size_t newlen)
{
nvlist_t *nvl;
const uint8_t *retoldp;
uint8_t operation;
size_t oldlen;
operation = 0;
if (oldp != NULL)
operation |= CAP_SYSCTL_READ;
if (newp != NULL)
operation |= CAP_SYSCTL_WRITE;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "sysctl");
nvlist_add_string(nvl, "name", name);
nvlist_add_number(nvl, "operation", (uint64_t)operation);
if (oldp == NULL && oldlenp != NULL)
nvlist_add_null(nvl, "justsize");
else if (oldlenp != NULL)
nvlist_add_number(nvl, "oldlen", (uint64_t)*oldlenp);
if (newp != NULL)
nvlist_add_binary(nvl, "newp", newp, newlen);
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL)
return (-1);
if (nvlist_get_number(nvl, "error") != 0) {
errno = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (-1);
}
if (oldp == NULL && oldlenp != NULL) {
*oldlenp = (size_t)nvlist_get_number(nvl, "oldlen");
} else if (oldp != NULL) {
retoldp = nvlist_get_binary(nvl, "oldp", &oldlen);
memcpy(oldp, retoldp, oldlen);
if (oldlenp != NULL)
*oldlenp = oldlen;
}
nvlist_destroy(nvl);
return (0);
}
int
cap_dns_type_limit(cap_channel_t *chan, const char * const *types,
size_t ntypes)
{
nvlist_t *limits;
unsigned int i;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL)
limits = nvlist_create(0);
else
limit_remove(limits, "type");
for (i = 0; i < ntypes; i++)
nvlist_addf_string(limits, types[i], "type%u", i);
return (cap_limit_set(chan, limits));
}
int
u_sysctl(int ns,
int *oid,
u_int namelen,
void *oldp,
size_t *oldlenp,
const void *newp,
size_t newlen)
{
nvlist_t *nvl = NULL, *nvl_resp = NULL;
int retval = 0;
const char *rbuf;
size_t r_len;
int r_errno;
#if 0
printf("sysctl: nl=%d, oldp=%p, oldlen=%d, newp=%p, newlen=%d\n",
namelen,
oldp,
(int) *oldlenp,
newp,
(int) newlen);
#endif
/* Create nvlist to populate the request into */
nvl = nvlist_create(0);
if (nvl == NULL) {
warn("nvlist_create");
retval = -1;
goto done;
}
/* Create nvlist for a sysctl_oid request */
nvlist_add_string(nvl, "type", "sysctl_oid");
nvlist_add_binary(nvl, "sysctl_oid", oid, namelen * sizeof(int));
/* XXX this sets errno as appropriate */
retval = u_sysctl_do_sysctl(nvl, ns, oldp, oldlenp, newp, newlen);
done:
if (nvl)
nvlist_destroy(nvl);
return (retval);
}
int
cap_setgrent(cap_channel_t *chan)
{
nvlist_t *nvl;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "setgrent");
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL)
return (0);
if (nvlist_get_number(nvl, "error") != 0) {
errno = nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (0);
}
nvlist_destroy(nvl);
return (1);
}
int
cap_dns_family_limit(cap_channel_t *chan, const int *families,
size_t nfamilies)
{
nvlist_t *limits;
unsigned int i;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL)
limits = nvlist_create(0);
else
limit_remove(limits, "family");
for (i = 0; i < nfamilies; i++) {
nvlist_addf_number(limits, (uint64_t)families[i],
"family%u", i);
}
return (cap_limit_set(chan, limits));
}
const char *aulookup_gid(gid_t gid, char *buf, size_t size)
{
char *name = NULL;
int rc;
if (report_format <= RPT_DEFAULT) {
snprintf(buf, size, "%d", gid);
return buf;
}
if (gid == -1) {
snprintf(buf, size, "unset");
return buf;
}
// Check the cache first
if (gid_list_created == 0) {
nvlist_create(&gid_nvl);
nvlist_clear(&gid_nvl);
gid_list_created = 1;
}
rc = nvlist_find_val(&gid_nvl, gid);
if (rc) {
name = gid_nvl.cur->name;
} else {
// Add it to cache
struct group *gr;
gr = getgrgid(gid);
if (gr) {
nvnode nv;
nv.name = strdup(gr->gr_name);
nv.val = gid;
nvlist_append(&gid_nvl, &nv);
name = gid_nvl.cur->name;
}
}
if (name != NULL)
snprintf(buf, size, "%s", name);
else
snprintf(buf, size, "unknown(%d)", gid);
return buf;
}
const char *aulookup_uid(uid_t uid, char *buf, size_t size)
{
char *name = NULL;
int rc;
if (report_format <= RPT_DEFAULT) {
snprintf(buf, size, "%d", uid);
return buf;
}
if (uid == -1) {
snprintf(buf, size, "unset");
return buf;
}
// Check the cache first
if (uid_list_created == 0) {
nvlist_create(&uid_nvl);
nvlist_clear(&uid_nvl);
uid_list_created = 1;
}
rc = nvlist_find_val(&uid_nvl, uid);
if (rc) {
name = uid_nvl.cur->name;
} else {
// Add it to cache
struct passwd *pw;
pw = getpwuid(uid);
if (pw) {
nvnode nv;
nv.name = strdup(pw->pw_name);
nv.val = uid;
nvlist_append(&uid_nvl, &nv);
name = uid_nvl.cur->name;
}
}
if (name != NULL)
snprintf(buf, size, "%s", name);
else
snprintf(buf, size, "unknown(%d)", uid);
return buf;
}
int
cap_dns_family_limit(cap_channel_t *chan, const int *families,
size_t nfamilies)
{
nvlist_t *limits;
unsigned int i;
char nvlname[64];
int n;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL)
limits = nvlist_create(0);
else
limit_remove(limits, "family");
for (i = 0; i < nfamilies; i++) {
n = snprintf(nvlname, sizeof(nvlname), "family%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_number(limits, nvlname, (uint64_t)families[i]);
}
return (cap_limit_set(chan, limits));
}
int
cap_dns_type_limit(cap_channel_t *chan, const char * const *types,
size_t ntypes)
{
nvlist_t *limits;
unsigned int i;
char nvlname[64];
int n;
if (cap_limit_get(chan, &limits) < 0)
return (-1);
if (limits == NULL)
limits = nvlist_create(0);
else
limit_remove(limits, "type");
for (i = 0; i < ntypes; i++) {
n = snprintf(nvlname, sizeof(nvlname), "type%u", i);
assert(n > 0 && n < (int)sizeof(nvlname));
nvlist_add_string(limits, nvlname, types[i]);
}
return (cap_limit_set(chan, limits));
}
int
cap_random_buf(cap_channel_t *chan, void *buf, size_t nbytes)
{
nvlist_t *nvl;
const void *randbuf;
uint8_t *ptr;
size_t left, randbufsize;
left = nbytes;
ptr = buf;
while (left > 0) {
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", "generate");
nvlist_add_number(nvl, "size",
(uint64_t)(left > MAXSIZE ? MAXSIZE : left));
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL)
return (-1);
if (nvlist_get_number(nvl, "error") != 0) {
errno = (int)nvlist_get_number(nvl, "error");
nvlist_destroy(nvl);
return (-1);
}
randbuf = nvlist_get_binary(nvl, "data", &randbufsize);
memcpy(ptr, randbuf, randbufsize);
nvlist_destroy(nvl);
ptr += randbufsize;
assert(left >= randbufsize);
left -= randbufsize;
}
return (0);
}
static int
cap_getgrcommon_r(cap_channel_t *chan, const char *cmd, const char *name,
gid_t gid, struct group *grp, char *buffer, size_t bufsize,
struct group **result)
{
nvlist_t *nvl;
bool getgr_r;
int error;
nvl = nvlist_create(0);
nvlist_add_string(nvl, "cmd", cmd);
if (strcmp(cmd, "getgrent") == 0 || strcmp(cmd, "getgrent_r") == 0) {
/* Add nothing. */
} else if (strcmp(cmd, "getgrnam") == 0 ||
strcmp(cmd, "getgrnam_r") == 0) {
nvlist_add_string(nvl, "name", name);
} else if (strcmp(cmd, "getgrgid") == 0 ||
strcmp(cmd, "getgrgid_r") == 0) {
nvlist_add_number(nvl, "gid", (uint64_t)gid);
} else {
abort();
}
nvl = cap_xfer_nvlist(chan, nvl, 0);
if (nvl == NULL) {
assert(errno != 0);
*result = NULL;
return (errno);
}
error = (int)nvlist_get_number(nvl, "error");
if (error != 0) {
nvlist_destroy(nvl);
*result = NULL;
return (error);
}
if (!nvlist_exists_string(nvl, "gr_name")) {
/* Not found. */
nvlist_destroy(nvl);
*result = NULL;
return (0);
}
getgr_r = (strcmp(cmd, "getgrent_r") == 0 ||
strcmp(cmd, "getgrnam_r") == 0 || strcmp(cmd, "getgrgid_r") == 0);
for (;;) {
error = group_unpack(nvl, grp, buffer, bufsize);
if (getgr_r || error != ERANGE)
break;
assert(buffer == gbuffer);
assert(bufsize == gbufsize);
error = group_resize();
if (error != 0)
break;
/* Update pointers after resize. */
buffer = gbuffer;
bufsize = gbufsize;
}
nvlist_destroy(nvl);
if (error == 0)
*result = grp;
else
*result = NULL;
return (error);
}
static nvlist_t *
nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds,
int flags)
{
const unsigned char *ptr;
nvlist_t *nvl, *retnvl, *tmpnvl;
nvpair_t *nvp;
size_t left;
bool isbe;
PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
left = size;
ptr = buf;
tmpnvl = NULL;
nvl = retnvl = nvlist_create(0);
if (nvl == NULL)
goto failed;
ptr = nvlist_unpack_header(nvl, ptr, nfds, &isbe, &left);
if (ptr == NULL)
goto failed;
if (nvl->nvl_flags != flags) {
ERRNO_SET(EILSEQ);
goto failed;
}
while (left > 0) {
ptr = nvpair_unpack(isbe, ptr, &left, &nvp);
if (ptr == NULL)
goto failed;
switch (nvpair_type(nvp)) {
case NV_TYPE_NULL:
ptr = nvpair_unpack_null(isbe, nvp, ptr, &left);
break;
case NV_TYPE_BOOL:
ptr = nvpair_unpack_bool(isbe, nvp, ptr, &left);
break;
case NV_TYPE_NUMBER:
ptr = nvpair_unpack_number(isbe, nvp, ptr, &left);
break;
case NV_TYPE_STRING:
ptr = nvpair_unpack_string(isbe, nvp, ptr, &left);
break;
case NV_TYPE_NVLIST:
ptr = nvpair_unpack_nvlist(isbe, nvp, ptr, &left, nfds,
&tmpnvl);
nvlist_set_parent(tmpnvl, nvp);
break;
#ifndef _KERNEL
case NV_TYPE_DESCRIPTOR:
ptr = nvpair_unpack_descriptor(isbe, nvp, ptr, &left,
fds, nfds);
break;
#endif
case NV_TYPE_BINARY:
ptr = nvpair_unpack_binary(isbe, nvp, ptr, &left);
break;
case NV_TYPE_NVLIST_UP:
if (nvl->nvl_parent == NULL)
goto failed;
nvl = nvpair_nvlist(nvl->nvl_parent);
nvpair_free_structure(nvp);
continue;
default:
PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
}
if (ptr == NULL)
goto failed;
nvlist_move_nvpair(nvl, nvp);
if (tmpnvl != NULL) {
nvl = tmpnvl;
tmpnvl = NULL;
}
}
return (retnvl);
failed:
nvlist_destroy(retnvl);
return (NULL);
}
int
main(void)
{
const nvlist_t *cnvl;
nvlist_t *nvl;
printf("1..94\n");
nvl = nvlist_create(0);
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
nvlist_add_null(nvl, "nvlist/null");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/true"));
nvlist_add_bool(nvl, "nvlist/bool/true", true);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_bool(nvl, "nvlist/bool/true"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/false"));
nvlist_add_bool(nvl, "nvlist/bool/false", false);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_bool(nvl, "nvlist/bool/false"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/0"));
nvlist_add_number(nvl, "nvlist/number/0", 0);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/0"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/1"));
nvlist_add_number(nvl, "nvlist/number/1", 1);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/1"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/-1"));
nvlist_add_number(nvl, "nvlist/number/-1", -1);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/-1"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string/"));
nvlist_add_string(nvl, "nvlist/string/", "");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string/x"));
nvlist_add_string(nvl, "nvlist/string/x", "x");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/"));
nvlist_add_stringf(nvl, "nvlist/stringf/", "%s", "");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/"));
CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/x"));
nvlist_add_stringf(nvl, "nvlist/stringf/x", "%s", "x");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/x"));
CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
nvlist_add_stringf(nvl, "nvlist/stringf/666Xabc", "%d%c%s", 666, 'X', "abc");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/x"));
nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_null(nvl, "nvlist/null"));
CHECK(nvlist_exists_bool(nvl, "nvlist/bool/true"));
CHECK(nvlist_exists_bool(nvl, "nvlist/bool/false"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/0"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/1"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/-1"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
CHECK(nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/"));
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/x"));
CHECK(nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist");
CHECK(nvlist_exists_null(cnvl, "nvlist/null"));
CHECK(nvlist_exists_bool(cnvl, "nvlist/bool/true"));
CHECK(nvlist_exists_bool(cnvl, "nvlist/bool/false"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/0"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/1"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/-1"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/UINT64_MAX"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/INT64_MIN"));
CHECK(nvlist_exists_number(cnvl, "nvlist/number/INT64_MAX"));
CHECK(nvlist_exists_string(cnvl, "nvlist/string/"));
CHECK(nvlist_exists_string(cnvl, "nvlist/string/x"));
CHECK(nvlist_exists_string(cnvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/"));
CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/x"));
CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/666Xabc"));
CHECK(nvlist_exists_descriptor(cnvl, "nvlist/descriptor/STDERR_FILENO"));
CHECK(nvlist_exists_binary(cnvl, "nvlist/binary/x"));
CHECK(nvlist_exists_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
nvlist_destroy(nvl);
return (0);
}
int
main(void)
{
nvlist_t *nvl;
printf("1..232\n");
nvl = nvlist_create(0);
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/null"));
CHECK(!nvlist_exists_number(nvl, "nvlist/null"));
CHECK(!nvlist_exists_string(nvl, "nvlist/null"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/null"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/null"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/null"));
nvlist_add_null(nvl, "nvlist/null");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/null"));
CHECK(nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/null"));
CHECK(!nvlist_exists_number(nvl, "nvlist/null"));
CHECK(!nvlist_exists_string(nvl, "nvlist/null"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/null"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/null"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_null(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_string(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/bool"));
nvlist_add_bool(nvl, "nvlist/bool", true);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_null(nvl, "nvlist/bool"));
CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_string(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists_null(nvl, "nvlist/number"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/number"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/number"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/number"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/number"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/number"));
nvlist_add_number(nvl, "nvlist/number", 0);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists_null(nvl, "nvlist/number"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/number"));
CHECK(nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/number"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/number"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/number"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/number"));
CHECK(!nvlist_exists(nvl, "nvlist/string"));
CHECK(!nvlist_exists_null(nvl, "nvlist/string"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/string"));
CHECK(!nvlist_exists_number(nvl, "nvlist/string"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/string"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/string"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/string"));
nvlist_add_string(nvl, "nvlist/string", "test");
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/string"));
CHECK(!nvlist_exists_null(nvl, "nvlist/string"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/string"));
CHECK(!nvlist_exists_number(nvl, "nvlist/string"));
CHECK(nvlist_exists_string(nvl, "nvlist/string"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/string"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/string"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/string"));
CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_null(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_number(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_string(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/nvlist"));
nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_null(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_number(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_string(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_null(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_number(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_string(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/descriptor"));
nvlist_add_descriptor(nvl, "nvlist/descriptor", STDERR_FILENO);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_null(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_number(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_string(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_number(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_string(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_add_binary(nvl, "nvlist/binary", "test", 4);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_number(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_string(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/binary"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
CHECK(nvlist_exists(nvl, "nvlist/null"));
CHECK(nvlist_exists(nvl, "nvlist/bool"));
CHECK(nvlist_exists(nvl, "nvlist/number"));
CHECK(nvlist_exists(nvl, "nvlist/string"));
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(nvlist_exists_null(nvl, "nvlist/null"));
CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(nvlist_exists_number(nvl, "nvlist/number"));
CHECK(nvlist_exists_string(nvl, "nvlist/string"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_null(nvl, "nvlist/null");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(nvlist_exists(nvl, "nvlist/bool"));
CHECK(nvlist_exists(nvl, "nvlist/number"));
CHECK(nvlist_exists(nvl, "nvlist/string"));
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(nvlist_exists_number(nvl, "nvlist/number"));
CHECK(nvlist_exists_string(nvl, "nvlist/string"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_bool(nvl, "nvlist/bool");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(nvlist_exists(nvl, "nvlist/number"));
CHECK(nvlist_exists(nvl, "nvlist/string"));
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(nvlist_exists_number(nvl, "nvlist/number"));
CHECK(nvlist_exists_string(nvl, "nvlist/string"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_number(nvl, "nvlist/number");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(nvlist_exists(nvl, "nvlist/string"));
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(nvlist_exists_string(nvl, "nvlist/string"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_string(nvl, "nvlist/string");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists(nvl, "nvlist/string"));
CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_nvlist(nvl, "nvlist/nvlist");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists(nvl, "nvlist/string"));
CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_descriptor(nvl, "nvlist/descriptor");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists(nvl, "nvlist/string"));
CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
nvlist_free_binary(nvl, "nvlist/binary");
CHECK(!nvlist_exists(nvl, "nvlist/null"));
CHECK(!nvlist_exists(nvl, "nvlist/bool"));
CHECK(!nvlist_exists(nvl, "nvlist/number"));
CHECK(!nvlist_exists(nvl, "nvlist/string"));
CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists(nvl, "nvlist/binary"));
CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
CHECK(nvlist_empty(nvl));
nvlist_destroy(nvl);
return (0);
}
void
service_message(struct service *service, struct service_connection *sconn)
{
nvlist_t *nvlin, *nvlout;
const char *cmd;
int error;
nvlin = cap_recv_nvlist(service_connection_get_chan(sconn));
if (nvlin == NULL) {
if (errno == ENOTCONN) {
pjdlog_debug(1, "Connection closed by the client.");
} else {
pjdlog_errno(LOG_ERR,
"Unable to receive message from client");
}
service_connection_remove(service, sconn);
return;
}
error = EDOOFUS;
nvlout = nvlist_create(0);
cmd = nvlist_get_string(nvlin, "cmd");
pjdlog_debug(1, "Command received from client: %s.", cmd);
if (pjdlog_debug_get() >= 2)
nvlist_fdump(nvlin, stderr);
if (strcmp(cmd, "limit_set") == 0) {
nvlist_t *nvllim;
nvllim = nvlist_take_nvlist(nvlin, "limits");
error = service->s_limit(service_connection_get_limits(sconn),
nvllim);
if (error == 0) {
service_connection_set_limits(sconn, nvllim);
/* Function consumes nvllim. */
} else {
nvlist_destroy(nvllim);
}
} else if (strcmp(cmd, "limit_get") == 0) {
const nvlist_t *nvllim;
nvllim = service_connection_get_limits(sconn);
if (nvllim != NULL)
nvlist_add_nvlist(nvlout, "limits", nvllim);
else
nvlist_add_null(nvlout, "limits");
error = 0;
} else if (strcmp(cmd, "clone") == 0) {
int sock;
sock = service_connection_clone(service, sconn);
if (sock == -1) {
error = errno;
} else {
nvlist_add_descriptor(nvlout, "sock", sock);
error = 0;
}
} else {
nvlout = nvlist_create(0);
error = service->s_command(cmd,
service_connection_get_limits(sconn), nvlin, nvlout);
}
nvlist_destroy(nvlin);
nvlist_add_number(nvlout, "error", (uint64_t)error);
pjdlog_debug(1, "Sending reply to client (error=%d).", error);
if (pjdlog_debug_get() >= 2)
nvlist_fdump(nvlout, stderr);
if (cap_send_nvlist(service_connection_get_chan(sconn), nvlout) == -1) {
pjdlog_errno(LOG_ERR, "Unable to send message to client");
service_connection_remove(service, sconn);
return;
}
}