/*
* write(2)
*
*/
ssize_t
alcove_sys_write(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
int index = 0;
int rindex = 0;
int fd = -1;
char buf[MAXMSGLEN] = {0};
size_t buflen = sizeof(buf);
int rv = 0;
/* fd */
if (alcove_decode_int(arg, len, &index, &fd) < 0)
return -1;
/* buf */
if (alcove_decode_iolist(arg, len, &index, buf, &buflen) < 0)
return -1;
rv = write(fd, buf, buflen);
if (rv < 0) {
rindex = alcove_mk_errno(reply, rlen, errno);
}
else {
ALCOVE_OK(reply, &rindex,
alcove_encode_longlong(reply, rlen, &rindex, rv));
}
return rindex;
}
ssize_t
alcove_sys_setenv(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
int index = 0;
char name[MAXMSGLEN] = {0};
size_t namelen = sizeof(name)-1;
char value[MAXMSGLEN] = {0};
size_t valuelen = sizeof(value)-1;
int overwrite = 0;
int rv = 0;
UNUSED(ap);
/* name */
if (alcove_decode_iolist(arg, len, &index, name, &namelen) < 0 ||
namelen == 0)
return -1;
/* value */
if (alcove_decode_iolist(arg, len, &index, value, &valuelen) < 0)
return -1;
/* overwrite */
if (alcove_decode_int(arg, len, &index, &overwrite) < 0)
return -1;
rv = setenv(name, value, overwrite);
return (rv < 0)
? alcove_mk_errno(reply, rlen, errno)
: alcove_mk_atom(reply, rlen, "ok");
}
/*
* kill(2)
*
*/
ssize_t
alcove_sys_kill(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
int index = 0;
pid_t pid = 0;
int signum = 0;
int rv = 0;
UNUSED(ap);
/* pid */
if (alcove_decode_int(arg, len, &index, &pid) < 0)
return -1;
/* signal */
switch (alcove_decode_constant(arg, len, &index, &signum,
alcove_signal_constants)) {
case 0:
break;
case 1:
return alcove_mk_error(reply, rlen, "enotsup");
default:
return -1;
}
rv = kill(pid, signum);
return (rv < 0)
? alcove_mk_errno(reply, rlen, errno)
: alcove_mk_atom(reply, rlen, "ok");
}
/*
* close(2)
*
*/
ssize_t
alcove_sys_close(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
int index = 0;
int fd = 0;
/* fd */
if (alcove_decode_int(arg, len, &index, &fd) < 0)
return -1;
return (close(fd) < 0)
? alcove_mk_errno(reply, rlen, errno)
: alcove_mk_atom(reply, rlen, "ok");
}
/*
* cap_fcntls_get(2)
*
*/
ssize_t
alcove_sys_cap_fcntls_get(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
#if defined(__FreeBSD__)
int index = 0;
int rindex = 0;
int rv = 0;
int fd = -1;
uint32_t rights = 0;
UNUSED(ap);
/* fd */
if (alcove_decode_int(arg, len, &index, &fd) < 0)
return -1;
rv = cap_fcntls_get(fd, &rights);
if (rv < 0)
return alcove_mk_errno(reply, rlen, errno);
ALCOVE_OK(
reply,
rlen,
&rindex,
alcove_encode_ulong(reply, rlen, &rindex, rights)
);
return rindex;
#else
UNUSED(ap);
UNUSED(arg);
UNUSED(len);
return alcove_mk_atom(reply, rlen, "undef");
#endif
}
/*
* setpriority(2)
*/
ssize_t
alcove_sys_setpriority(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
int index = 0;
int which = 0;
int who = 0;
int prio = 0;
switch (alcove_decode_define(arg, len, &index, &which,
alcove_prio_constants)) {
case 0:
break;
case 1:
return alcove_mk_error(reply, rlen, "unsupported");
default:
return -1;
}
switch (alcove_decode_define(arg, len, &index, &who,
alcove_prio_constants)) {
case 0:
break;
case 1:
return alcove_mk_error(reply, rlen, "unsupported");
default:
return -1;
}
if (alcove_decode_int(arg, len, &index, &prio) < 0)
return -1;
if (setpriority(which, who, prio) < 0)
return alcove_mk_errno(reply, rlen, errno);
return alcove_mk_atom(reply, rlen, "ok");
}
/*
* ptrace(2)
*
*/
ssize_t
alcove_sys_ptrace(alcove_state_t *ap, const char *arg, size_t len,
char *reply, size_t rlen)
{
#if defined(__linux__)
int index = 0;
int rindex = 0;
int type = 0;
int arity = 0;
int request = 0;
pid_t pid = 0;
alcove_ptrace_arg_t addr = {0};
alcove_ptrace_arg_t data = {0};
alcove_alloc_t *elem = NULL;
ssize_t nelem = 0;
long rv = 0;
UNUSED(ap);
/* request */
switch (alcove_decode_constant(arg, len, &index, &request,
alcove_ptrace_constants)) {
case 0:
break;
case 1:
return alcove_mk_error(reply, rlen, "enotsup");
default:
return -1;
}
/* pid */
if (alcove_decode_int(arg, len, &index, &pid) < 0)
return -1;
/* addr */
if (alcove_get_type(arg, len, &index, &type, &arity) < 0)
return -1;
switch (type) {
case ERL_SMALL_INTEGER_EXT:
case ERL_INTEGER_EXT:
addr.type = ALCOVE_PTRACEARG_INT;
if (alcove_decode_ulong(arg, len, &index, &addr.arg) < 0)
return -1;
break;
case ERL_LIST_EXT:
addr.type = ALCOVE_PTRACEARG_CSTRUCT;
addr.len = sizeof(addr.data);
if (alcove_decode_cstruct(arg, len, &index, addr.data,
&(addr.len), &elem, &nelem) < 0)
return -1;
break;
case ERL_BINARY_EXT:
addr.type = ALCOVE_PTRACEARG_BINARY;
if (arity > sizeof(addr.data))
return -1;
if (alcove_decode_binary(arg, len, &index,
addr.data, &addr.len) < 0)
return -1;
break;
default:
return -1;
}
/* data */
if (alcove_get_type(arg, len, &index, &type, &arity) < 0)
return -1;
switch (type) {
case ERL_SMALL_INTEGER_EXT:
case ERL_INTEGER_EXT:
data.type = ALCOVE_PTRACEARG_INT;
if (alcove_decode_ulong(arg, len, &index, &data.arg) < 0)
return -1;
break;
case ERL_LIST_EXT:
data.type = ALCOVE_PTRACEARG_CSTRUCT;
data.len = sizeof(data.data);
if (alcove_decode_cstruct(arg, len, &index, data.data,
&(data.len), &elem, &nelem) < 0)
return -1;
break;
case ERL_BINARY_EXT:
data.type = ALCOVE_PTRACEARG_BINARY;
if (arity > sizeof(data.data))
return -1;
if (alcove_decode_binary(arg, len, &index,
data.data, &data.len) < 0)
return -1;
break;
default:
return -1;
}
errno = 0;
rv = ptrace(request, pid, PRTRACEARG(addr), PRTRACEARG(data));
if (errno)
return alcove_mk_errno(reply, rlen, errno);
ALCOVE_ERR(alcove_encode_version(reply, rlen, &rindex));
ALCOVE_ERR(alcove_encode_tuple_header(reply, rlen, &rindex, 4));
ALCOVE_ERR(alcove_encode_atom(reply, rlen, &rindex, "ok"));
ALCOVE_ERR(alcove_encode_long(reply, rlen, &rindex, rv));
switch (addr.type) {
case ALCOVE_PTRACEARG_CSTRUCT:
ALCOVE_ERR(alcove_encode_cstruct(reply, rlen, &rindex,
addr.data, addr.len, elem, nelem));
break;
case ALCOVE_PTRACEARG_INT: /* return an empty binary */
case ALCOVE_PTRACEARG_BINARY:
ALCOVE_ERR(alcove_encode_binary(reply, rlen, &rindex, addr.data,
addr.len));
break;
default:
return -1;
}
switch (data.type) {
case ALCOVE_PTRACEARG_CSTRUCT:
ALCOVE_ERR(alcove_encode_cstruct(reply, rlen, &rindex,
data.data, data.len, elem, nelem));
break;
case ALCOVE_PTRACEARG_INT: /* return an empty binary */
case ALCOVE_PTRACEARG_BINARY:
ALCOVE_ERR(alcove_encode_binary(reply, rlen, &rindex, data.data,
data.len));
break;
default:
return -1;
}
return rindex;
#else
UNUSED(ap);
UNUSED(arg);
UNUSED(len);
return alcove_mk_atom(reply, rlen, "undef");
#endif
}
