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);
}
static struct hostent *
hostent_unpack(const nvlist_t *nvl, struct hostent *hp)
{
unsigned int ii, nitems;
char nvlname[64];
int n;
hostent_free(hp);
hp->h_name = strdup(nvlist_get_string(nvl, "name"));
if (hp->h_name == NULL)
goto fail;
hp->h_addrtype = (int)nvlist_get_number(nvl, "addrtype");
hp->h_length = (int)nvlist_get_number(nvl, "length");
nitems = (unsigned int)nvlist_get_number(nvl, "naliases");
hp->h_aliases = calloc(sizeof(hp->h_aliases[0]), nitems + 1);
if (hp->h_aliases == NULL)
goto fail;
for (ii = 0; ii < nitems; ii++) {
n = snprintf(nvlname, sizeof(nvlname), "alias%u", ii);
assert(n > 0 && n < (int)sizeof(nvlname));
hp->h_aliases[ii] =
strdup(nvlist_get_string(nvl, nvlname));
if (hp->h_aliases[ii] == NULL)
goto fail;
}
hp->h_aliases[ii] = NULL;
nitems = (unsigned int)nvlist_get_number(nvl, "naddrs");
hp->h_addr_list = calloc(sizeof(hp->h_addr_list[0]), nitems + 1);
if (hp->h_addr_list == NULL)
goto fail;
for (ii = 0; ii < nitems; ii++) {
hp->h_addr_list[ii] = malloc(hp->h_length);
if (hp->h_addr_list[ii] == NULL)
goto fail;
n = snprintf(nvlname, sizeof(nvlname), "addr%u", ii);
assert(n > 0 && n < (int)sizeof(nvlname));
bcopy(nvlist_get_binary(nvl, nvlname, NULL),
hp->h_addr_list[ii], hp->h_length);
}
hp->h_addr_list[ii] = NULL;
return (hp);
fail:
hostent_free(hp);
h_errno = NO_RECOVERY;
return (NULL);
}
static int
pwd_allowed_users(const nvlist_t *oldlimits, const nvlist_t *newlimits)
{
const char *name, *uname;
void *cookie;
uid_t uid;
int type;
cookie = NULL;
while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) {
switch (type) {
case NV_TYPE_NUMBER:
uid = (uid_t)nvlist_get_number(newlimits, name);
uname = NULL;
break;
case NV_TYPE_STRING:
uid = (uid_t)-1;
uname = nvlist_get_string(newlimits, name);
break;
default:
return (EINVAL);
}
if (!pwd_allowed_user(oldlimits, uname, uid))
return (ENOTCAPABLE);
}
return (0);
}
static struct addrinfo *
addrinfo_unpack(const nvlist_t *nvl)
{
struct addrinfo *ai;
const void *addr;
size_t addrlen;
const char *canonname;
addr = nvlist_get_binary(nvl, "ai_addr", &addrlen);
ai = malloc(sizeof(*ai) + addrlen);
if (ai == NULL)
return (NULL);
ai->ai_flags = (int)nvlist_get_number(nvl, "ai_flags");
ai->ai_family = (int)nvlist_get_number(nvl, "ai_family");
ai->ai_socktype = (int)nvlist_get_number(nvl, "ai_socktype");
ai->ai_protocol = (int)nvlist_get_number(nvl, "ai_protocol");
ai->ai_addrlen = (socklen_t)addrlen;
canonname = nvlist_get_string(nvl, "ai_canonname");
if (canonname != NULL) {
ai->ai_canonname = strdup(canonname);
if (ai->ai_canonname == NULL) {
free(ai);
return (NULL);
}
} else {
ai->ai_canonname = NULL;
}
ai->ai_addr = (void *)(ai + 1);
bcopy(addr, ai->ai_addr, addrlen);
ai->ai_next = NULL;
return (ai);
}
static int
grp_allowed_groups(const nvlist_t *oldlimits, const nvlist_t *newlimits)
{
const char *name, *gname;
void *cookie;
gid_t gid;
int type;
cookie = NULL;
while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) {
switch (type) {
case NV_TYPE_NUMBER:
gid = (gid_t)nvlist_get_number(newlimits, name);
gname = NULL;
break;
case NV_TYPE_STRING:
gid = (gid_t)-1;
gname = nvlist_get_string(newlimits, name);
break;
default:
return (EINVAL);
}
if (!grp_allowed_group(oldlimits, gname, gid))
return (ENOTCAPABLE);
}
return (0);
}
static int
group_unpack_members(const nvlist_t *nvl, char ***fieldp, char **bufferp,
size_t *bufsizep)
{
const char *mem;
char **outstrs, *str, nvlname[64];
size_t nmem, datasize, strsize;
unsigned int ii;
int n;
if (!nvlist_exists_number(nvl, "gr_nmem")) {
datasize = _ALIGNBYTES + sizeof(char *);
if (datasize >= *bufsizep)
return (ERANGE);
outstrs = (char **)_ALIGN(*bufferp);
outstrs[0] = NULL;
*fieldp = outstrs;
*bufferp += datasize;
*bufsizep -= datasize;
return (0);
}
nmem = (size_t)nvlist_get_number(nvl, "gr_nmem");
datasize = _ALIGNBYTES + sizeof(char *) * (nmem + 1);
for (ii = 0; ii < nmem; ii++) {
n = snprintf(nvlname, sizeof(nvlname), "gr_mem[%u]", ii);
assert(n > 0 && n < (int)sizeof(nvlname));
mem = dnvlist_get_string(nvl, nvlname, NULL);
if (mem == NULL)
return (EINVAL);
datasize += strlen(mem) + 1;
}
if (datasize >= *bufsizep)
return (ERANGE);
outstrs = (char **)_ALIGN(*bufferp);
str = (char *)outstrs + sizeof(char *) * (nmem + 1);
for (ii = 0; ii < nmem; ii++) {
n = snprintf(nvlname, sizeof(nvlname), "gr_mem[%u]", ii);
assert(n > 0 && n < (int)sizeof(nvlname));
mem = nvlist_get_string(nvl, nvlname);
strsize = strlen(mem) + 1;
memcpy(str, mem, strsize);
outstrs[ii] = str;
str += strsize;
}
assert(ii == nmem);
outstrs[ii] = NULL;
*fieldp = outstrs;
*bufferp += datasize;
*bufsizep -= datasize;
return (0);
}
static void
casper_message(const cap_channel_t *capcas, struct service *service)
{
const char *cmd;
nvlist_t *nvl;
nvl = cap_recv_nvlist(capcas);
if (nvl == NULL)
pjdlog_exit(1, "Unable to receive message from Casper");
cmd = nvlist_get_string(nvl, "cmd");
if (strcmp(cmd, "connection") == 0)
casper_message_connection(service, nvl);
else
PJDLOG_ABORT("Unknown command from Casper: %s.", cmd);
}
static int
group_unpack_string(const nvlist_t *nvl, const char *fieldname, char **fieldp,
char **bufferp, size_t *bufsizep)
{
const char *str;
size_t len;
str = nvlist_get_string(nvl, fieldname);
len = strlcpy(*bufferp, str, *bufsizep);
if (len >= *bufsizep)
return (ERANGE);
*fieldp = *bufferp;
*bufferp += len + 1;
*bufsizep -= len + 1;
return (0);
}
static int
pwd_getpwnam(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout)
{
struct passwd *pwd;
const char *name;
if (!nvlist_exists_string(nvlin, "name"))
return (EINVAL);
name = nvlist_get_string(nvlin, "name");
PJDLOG_ASSERT(name != NULL);
errno = 0;
pwd = getpwnam(name);
if (errno != 0)
return (errno);
(void)pwd_pack(limits, pwd, nvlout);
return (0);
}
static bool
pwd_allowed_user(const nvlist_t *limits, const char *uname, uid_t uid)
{
const char *name;
void *cookie;
int type;
if (limits == NULL)
return (true);
/*
* If no limit was set on allowed users, then all users are allowed.
*/
if (!nvlist_exists_nvlist(limits, "users"))
return (true);
limits = nvlist_get_nvlist(limits, "users");
cookie = NULL;
while ((name = nvlist_next(limits, &type, &cookie)) != NULL) {
switch (type) {
case NV_TYPE_NUMBER:
if (uid != (uid_t)-1 &&
nvlist_get_number(limits, name) == (uint64_t)uid) {
return (true);
}
break;
case NV_TYPE_STRING:
if (uname != NULL &&
strcmp(nvlist_get_string(limits, name),
uname) == 0) {
return (true);
}
break;
default:
PJDLOG_ABORT("Unexpected type %d.", type);
}
}
return (false);
}
static bool
grp_allowed_group(const nvlist_t *limits, const char *gname, gid_t gid)
{
const char *name;
void *cookie;
int type;
if (limits == NULL)
return (true);
/*
* If no limit was set on allowed groups, then all groups are allowed.
*/
if (!nvlist_exists_nvlist(limits, "groups"))
return (true);
limits = nvlist_get_nvlist(limits, "groups");
cookie = NULL;
while ((name = nvlist_next(limits, &type, &cookie)) != NULL) {
switch (type) {
case NV_TYPE_NUMBER:
if (gid != (gid_t)-1 &&
nvlist_get_number(limits, name) == (uint64_t)gid) {
return (true);
}
break;
case NV_TYPE_STRING:
if (gname != NULL &&
strcmp(nvlist_get_string(limits, name),
gname) == 0) {
return (true);
}
break;
default:
abort();
}
}
return (false);
}
static void
print_subsystem_schema(const nvlist_t * subsystem_schema)
{
const char *name, *type;
const nvlist_t *parameter;
void *it;
int nvtype;
it = NULL;
while ((name = nvlist_next(subsystem_schema, &nvtype, &it)) != NULL) {
parameter = nvlist_get_nvlist(subsystem_schema, name);
type = nvlist_get_string(parameter, TYPE_SCHEMA_NAME);
printf("\t%s : %s", name, type);
if (dnvlist_get_bool(parameter, REQUIRED_SCHEMA_NAME, false))
printf(" (required)");
else if (nvlist_exists(parameter, DEFAULT_SCHEMA_NAME))
print_default_value(parameter, type);
else
printf(" (optional)");
printf("\n");
}
}
static void
print_default_value(const nvlist_t *parameter, const char *type)
{
const uint8_t *mac;
size_t size;
if (strcasecmp(type, "bool") == 0)
printf(" (default = %s)",
nvlist_get_bool(parameter, DEFAULT_SCHEMA_NAME) ? "true" :
"false");
else if (strcasecmp(type, "string") == 0)
printf(" (default = %s)",
nvlist_get_string(parameter, DEFAULT_SCHEMA_NAME));
else if (strcasecmp(type, "uint8_t") == 0)
printf(" (default = %ju)",
(uintmax_t)nvlist_get_number(parameter,
DEFAULT_SCHEMA_NAME));
else if (strcasecmp(type, "uint16_t") == 0)
printf(" (default = %ju)",
(uintmax_t)nvlist_get_number(parameter,
DEFAULT_SCHEMA_NAME));
else if (strcasecmp(type, "uint32_t") == 0)
printf(" (default = %ju)",
(uintmax_t)nvlist_get_number(parameter,
DEFAULT_SCHEMA_NAME));
else if (strcasecmp(type, "uint64_t") == 0)
printf(" (default = %ju)",
(uintmax_t)nvlist_get_number(parameter,
DEFAULT_SCHEMA_NAME));
else if (strcasecmp(type, "unicast-mac") == 0) {
mac = nvlist_get_binary(parameter, DEFAULT_SCHEMA_NAME, &size);
printf(" (default = %02x:%02x:%02x:%02x:%02x:%02x)", mac[0],
mac[1], mac[2], mac[3], mac[4], mac[5]);
} else
errx(1, "Unexpected type in schema: '%s'", type);
}
static int
sysctl_command(const char *cmd, const nvlist_t *limits, nvlist_t *nvlin,
nvlist_t *nvlout)
{
const char *name;
const void *newp;
void *oldp;
uint64_t operation;
size_t oldlen, newlen;
size_t *oldlenp;
int error;
if (strcmp(cmd, "sysctl") != 0)
return (EINVAL);
error = sysctl_check_one(nvlin, false);
if (error != 0)
return (error);
name = nvlist_get_string(nvlin, "name");
operation = nvlist_get_number(nvlin, "operation");
if (!sysctl_allowed(limits, name, operation))
return (ENOTCAPABLE);
if ((operation & CAP_SYSCTL_WRITE) != 0) {
if (!nvlist_exists_binary(nvlin, "newp"))
return (EINVAL);
newp = nvlist_get_binary(nvlin, "newp", &newlen);
assert(newp != NULL && newlen > 0);
} else {
newp = NULL;
newlen = 0;
}
if ((operation & CAP_SYSCTL_READ) != 0) {
if (nvlist_exists_null(nvlin, "justsize")) {
oldp = NULL;
oldlen = 0;
oldlenp = &oldlen;
} else {
if (!nvlist_exists_number(nvlin, "oldlen"))
return (EINVAL);
oldlen = (size_t)nvlist_get_number(nvlin, "oldlen");
if (oldlen == 0)
return (EINVAL);
oldp = calloc(1, oldlen);
if (oldp == NULL)
return (ENOMEM);
oldlenp = &oldlen;
}
} else {
oldp = NULL;
oldlen = 0;
oldlenp = NULL;
}
if (sysctlbyname(name, oldp, oldlenp, newp, newlen) == -1) {
error = errno;
free(oldp);
return (error);
}
if ((operation & CAP_SYSCTL_READ) != 0) {
if (nvlist_exists_null(nvlin, "justsize"))
nvlist_add_number(nvlout, "oldlen", (uint64_t)oldlen);
else
nvlist_move_binary(nvlout, "oldp", oldp, oldlen);
}
return (0);
}
static void
parent(int sock)
{
nvlist_t *nvl;
const nvlist_t *cnvl;
const char *name, *cname;
void *cookie, *ccookie;
int type, ctype;
size_t size;
nvl = nvlist_recv(sock);
CHECK(nvlist_error(nvl) == 0);
if (nvlist_error(nvl) != 0)
err(1, "nvlist_recv() failed");
cookie = NULL;
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_BOOL);
CHECK(strcmp(name, "nvlist/bool/true") == 0);
CHECK(nvlist_get_bool(nvl, name) == true);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_BOOL);
CHECK(strcmp(name, "nvlist/bool/false") == 0);
CHECK(nvlist_get_bool(nvl, name) == false);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/0") == 0);
CHECK(nvlist_get_number(nvl, name) == 0);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/1") == 0);
CHECK(nvlist_get_number(nvl, name) == 1);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/-1") == 0);
CHECK((int)nvlist_get_number(nvl, name) == -1);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/UINT64_MAX") == 0);
CHECK(nvlist_get_number(nvl, name) == UINT64_MAX);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/INT64_MIN") == 0);
CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MIN);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NUMBER);
CHECK(strcmp(name, "nvlist/number/INT64_MAX") == 0);
CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MAX);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_STRING);
CHECK(strcmp(name, "nvlist/string/") == 0);
CHECK(strcmp(nvlist_get_string(nvl, name), "") == 0);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_STRING);
CHECK(strcmp(name, "nvlist/string/x") == 0);
CHECK(strcmp(nvlist_get_string(nvl, name), "x") == 0);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_STRING);
CHECK(strcmp(name, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
CHECK(strcmp(nvlist_get_string(nvl, name), "abcdefghijklmnopqrstuvwxyz") == 0);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_DESCRIPTOR);
CHECK(strcmp(name, "nvlist/descriptor/STDERR_FILENO") == 0);
CHECK(fd_is_valid(nvlist_get_descriptor(nvl, name)));
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_BINARY);
CHECK(strcmp(name, "nvlist/binary/x") == 0);
CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "x", 1) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "x", 1) == 0);
CHECK(size == 1);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_BINARY);
CHECK(strcmp(name, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
name = nvlist_next(nvl, &type, &cookie);
CHECK(name != NULL);
CHECK(type == NV_TYPE_NVLIST);
CHECK(strcmp(name, "nvlist/nvlist") == 0);
cnvl = nvlist_get_nvlist(nvl, name);
ccookie = NULL;
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_BOOL);
CHECK(strcmp(cname, "nvlist/bool/true") == 0);
CHECK(nvlist_get_bool(cnvl, cname) == true);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_BOOL);
CHECK(strcmp(cname, "nvlist/bool/false") == 0);
CHECK(nvlist_get_bool(cnvl, cname) == false);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/0") == 0);
CHECK(nvlist_get_number(cnvl, cname) == 0);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/1") == 0);
CHECK(nvlist_get_number(cnvl, cname) == 1);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/-1") == 0);
CHECK((int)nvlist_get_number(cnvl, cname) == -1);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/UINT64_MAX") == 0);
CHECK(nvlist_get_number(cnvl, cname) == UINT64_MAX);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/INT64_MIN") == 0);
CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MIN);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_NUMBER);
CHECK(strcmp(cname, "nvlist/number/INT64_MAX") == 0);
CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MAX);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_STRING);
CHECK(strcmp(cname, "nvlist/string/") == 0);
CHECK(strcmp(nvlist_get_string(cnvl, cname), "") == 0);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_STRING);
CHECK(strcmp(cname, "nvlist/string/x") == 0);
CHECK(strcmp(nvlist_get_string(cnvl, cname), "x") == 0);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_STRING);
CHECK(strcmp(cname, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
CHECK(strcmp(nvlist_get_string(cnvl, cname), "abcdefghijklmnopqrstuvwxyz") == 0);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_DESCRIPTOR);
CHECK(strcmp(cname, "nvlist/descriptor/STDERR_FILENO") == 0);
CHECK(fd_is_valid(nvlist_get_descriptor(cnvl, cname)));
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_BINARY);
CHECK(strcmp(cname, "nvlist/binary/x") == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "x", 1) == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "x", 1) == 0);
CHECK(size == 1);
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname != NULL);
CHECK(ctype == NV_TYPE_BINARY);
CHECK(strcmp(cname, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
cname = nvlist_next(cnvl, &ctype, &ccookie);
CHECK(cname == NULL);
name = nvlist_next(nvl, &type, &cookie);
CHECK(name == NULL);
}
int
main(int argc, char *argv[])
{
int fd[2];
socketpair(PF_UNIX, SOCK_STREAM, 0, fd);
int kq = kqueue();
struct kevent ke;
memset(&ke, 0, sizeof(ke));
EV_SET(&ke, fd[0], EVFILT_READ, EV_ADD, 0, 0, NULL);
kevent(kq, &ke, 1, NULL, 0, NULL);
memset(&ke, 0, sizeof(ke));
EV_SET(&ke, fd[1], EVFILT_READ, EV_ADD, 0, 0, NULL);
kevent(kq, &ke, 1, NULL, 0, NULL);
signal(SIGWINCH, resize);
nvlist_t *nvl = NULL;
for (;;) {
if (res) {
struct winsize size;
ioctl(1, TIOCGWINSZ, &size);
nvl = nvlist_create(0);
nvlist_add_string(nvl, "type", "resize");
nvlist_add_number(nvl, "rows", size.ws_row);
nvlist_add_number(nvl, "cols", size.ws_col);
if (nvlist_send(fd[0], nvl) < 0)
err(1, "nvlist_send()");
nvlist_destroy(nvl);
res = 0;
}
memset(&ke, 0, sizeof(ke));
int i = kevent(kq, NULL, 0, &ke, 1, NULL);
if (i == -1) {
if (errno == EINTR)
continue;
err(1, "kevent()");
} else if (i == 0)
continue;
if (ke.ident == fd[0]) {
nvl = nvlist_recv(fd[0]);
if (nvl == NULL)
err(1, "nvlist_recv()");
const char *type = nvlist_get_string(nvl, "type");
if (strcmp(type, "ack") == 0) {
int ok = nvlist_get_bool(nvl, "ok");
printf("received ack, ok?: %s\n", ok ? "true" : "false");
}
nvlist_destroy(nvl);
} else if (ke.ident == fd[1]) {
nvl = nvlist_recv(fd[1]);
if (nvl == NULL)
err(1, "nvlist_recv()");
const char *type = nvlist_get_string(nvl, "type");
if (strcmp(type, "resize") == 0) {
int rows = nvlist_get_number(nvl, "rows");
int cows = nvlist_get_number(nvl, "cols");
printf("got resize signal. new size: %d %d\n", rows, cows);
}
nvlist_destroy(nvl);
nvl = nvlist_create(0);
nvlist_add_string(nvl, "type", "ack");
nvlist_add_bool(nvl, "ok", 1);
if (nvlist_send(fd[1], nvl) < 0)
err(1, "nvlist_send()");
nvlist_destroy(nvl);
}
}
}
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;
}
}
int
main(void)
{
const nvlist_t *cnvl;
nvlist_t *nvl;
size_t size;
printf("1..83\n");
nvl = nvlist_create(0);
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/true"));
nvlist_add_bool(nvl, "nvlist/bool/true", true);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true);
CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/false"));
nvlist_add_bool(nvl, "nvlist/bool/false", false);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false);
CHECK(!nvlist_exists_number(nvl, "nvlist/number/0"));
nvlist_add_number(nvl, "nvlist/number/0", 0);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0);
CHECK(!nvlist_exists_number(nvl, "nvlist/number/1"));
nvlist_add_number(nvl, "nvlist/number/1", 1);
CHECK(nvlist_error(nvl) == 0);
CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1);
CHECK(!nvlist_exists_number(nvl, "nvlist/number/-1"));
nvlist_add_number(nvl, "nvlist/number/-1", -1);
CHECK(nvlist_error(nvl) == 0);
CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -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_get_number(nvl, "nvlist/number/UINT64_MAX") == 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((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == 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((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX);
CHECK(!nvlist_exists_string(nvl, "nvlist/string/"));
nvlist_add_string(nvl, "nvlist/string/", "");
CHECK(nvlist_error(nvl) == 0);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0);
CHECK(!nvlist_exists_string(nvl, "nvlist/string/x"));
nvlist_add_string(nvl, "nvlist/string/x", "x");
CHECK(nvlist_error(nvl) == 0);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0);
CHECK(!nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
CHECK(nvlist_error(nvl) == 0);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
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(fd_is_valid(nvlist_get_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(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0);
CHECK(size == 1);
CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_error(nvl) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
CHECK(nvlist_error(nvl) == 0);
cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist");
CHECK(nvlist_get_bool(cnvl, "nvlist/bool/true") == true);
CHECK(nvlist_get_bool(cnvl, "nvlist/bool/false") == false);
CHECK(nvlist_get_number(cnvl, "nvlist/number/0") == 0);
CHECK(nvlist_get_number(cnvl, "nvlist/number/1") == 1);
CHECK((int)nvlist_get_number(cnvl, "nvlist/number/-1") == -1);
CHECK(nvlist_get_number(cnvl, "nvlist/number/UINT64_MAX") == UINT64_MAX);
CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MIN") == INT64_MIN);
CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MAX") == INT64_MAX);
CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/"), "") == 0);
CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/x"), "x") == 0);
CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
/* TODO */
CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", NULL), "x", 1) == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", &size), "x", 1) == 0);
CHECK(size == 1);
CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true);
CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false);
CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0);
CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1);
CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -1);
CHECK(nvlist_get_number(nvl, "nvlist/number/UINT64_MAX") == UINT64_MAX);
CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == INT64_MIN);
CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0);
CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
CHECK(fd_is_valid(nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO")));
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0);
CHECK(size == 1);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
nvlist_destroy(nvl);
return (0);
}
