static void port_server_cmd_create(char * token, Channel * c) {
int err = 0;
PortRedirectionInfo * port = loc_alloc_zero(sizeof(PortRedirectionInfo));
PortServer * server;
json_read_struct(&c->inp, read_port_server_property, port);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
/* In case the current channel is a proxy (value-add), use the
* target channel.
*/
port->c = proxy_get_target_channel(c);
if (port->c == NULL) port->c = c;
server = create_port_redirection(port);
if (server == NULL) err = errno;
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, err);
if (err) write_stringz(&c->out, "null");
else {
write_port_server_info(&c->out, server);
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
static void command_open(char * token, Channel * c) {
char path[FILE_PATH_SIZE];
unsigned long flags = 0;
FileAttrs attrs;
int file = -1;
int err = 0;
OpenFileInfo * handle = NULL;
read_path(&c->inp, path, sizeof(path));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
flags = json_read_ulong(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
memset(&attrs, 0, sizeof(FileAttrs));
json_read_struct(&c->inp, read_file_attrs, &attrs);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if ((attrs.flags & ATTR_PERMISSIONS) == 0) {
attrs.permissions = 0775;
}
file = open(path, to_local_open_flags(flags), attrs.permissions);
if (file < 0) {
err = errno;
}
else {
handle = create_open_file_info(c, path, file, NULL);
}
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_fs_errno(&c->out, err);
write_file_handle(&c->out, handle);
write_stream(&c->out, MARKER_EOM);
}
static void command_mkdir(char * token, Channel * c) {
char path[FILE_PATH_SIZE];
FileAttrs attrs;
int err = 0;
int mode = 0777;
read_path(&c->inp, path, sizeof(path));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
memset(&attrs, 0, sizeof(FileAttrs));
json_read_struct(&c->inp, read_file_attrs, &attrs);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if (attrs.flags & ATTR_PERMISSIONS) {
mode = attrs.permissions;
}
#if defined(_WRS_KERNEL)
if (mkdir(path) < 0) err = errno;
#else
if (mkdir(path, mode) < 0) err = errno;
#endif
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_fs_errno(&c->out, err);
write_stream(&c->out, MARKER_EOM);
}
static void command_setstat(char * token, Channel * c) {
char path[FILE_PATH_SIZE];
FileAttrs attrs;
int err = 0;
read_path(&c->inp, path, sizeof(path));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
memset(&attrs, 0, sizeof(FileAttrs));
json_read_struct(&c->inp, read_file_attrs, &attrs);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if (attrs.flags & ATTR_SIZE) {
if (truncate(path, attrs.size) < 0) err = errno;
}
#if !defined(WIN32) && !defined(_WRS_KERNEL)
if (attrs.flags & ATTR_UIDGID) {
if (chown(path, attrs.uid, attrs.gid) < 0) err = errno;
}
#endif
if (attrs.flags & ATTR_PERMISSIONS) {
if (chmod(path, attrs.permissions) < 0) err = errno;
}
if (attrs.flags & ATTR_ACMODTIME) {
struct utimbuf buf;
buf.actime = (long)(attrs.atime / 1000);
buf.modtime = (long)(attrs.mtime / 1000);
if (utime(path, &buf) < 0) err = errno;
}
reply_setstat(token, &c->out, err);
}
static void port_server_cmd_create(char * token, Channel * c) {
int err = 0;
PortAttribute * attrs = NULL;
PortServer * server;
Channel * port_channel;
json_read_struct(&c->inp, read_port_server_property, &attrs);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
/* In case the current channel is a proxy (value-add), use the
* target channel. Otherwise, use the provided channel. */
port_channel = proxy_get_target_channel(c);
if (port_channel == NULL) port_channel = c;
server = create_port_server(c, attrs, NULL, NULL, NULL, NULL);
if (server == NULL) err = errno;
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, err);
if (err) write_stringz(&c->out, "null");
else {
write_port_server_info(&c->out, server);
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
static void command_disassemble(char * token, Channel * c) {
int error = 0;
Context * ctx = NULL;
DisassembleCmdArgs * args = (DisassembleCmdArgs *)loc_alloc_zero(sizeof(DisassembleCmdArgs));
json_read_string(&c->inp, args->id, sizeof(args->id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args->addr = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args->size = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
json_read_struct(&c->inp, read_disassembly_params, args);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
ctx = id2ctx(args->id);
if (ctx == NULL) error = ERR_INV_CONTEXT;
else if (ctx->exited) error = ERR_ALREADY_EXITED;
else if (context_get_group(ctx, CONTEXT_GROUP_PROCESS)->mem_access == 0) error = ERR_INV_CONTEXT;
if (error != 0) {
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, error);
write_stringz(&c->out, "null");
write_stream(&c->out, MARKER_EOM);
loc_free(args);
}
else {
channel_lock(args->c = c);
strlcpy(args->token, token, sizeof(args->token));
post_safe_event(ctx, safe_event_disassemble, args);
}
}
static void getcapabilities_cb(Channel * c, void * x, int error) {
Trap trap;
PortConnection * conn = (PortConnection *)x;
PortAttribute * attr = conn->server->redir_info->attrs;
OutputStream * out = &conn->server->channel->out;
if (set_trap(&trap)) {
if (!error) {
error = read_errno(&c->inp);
json_read_struct(&c->inp, read_getcapabilities_struct, (void *)conn);
json_test_char(&c->inp, MARKER_EOA);
json_test_char(&c->inp, MARKER_EOM);
}
clear_trap(&trap);
}
else {
error = trap.error;
}
if (error) {
connect_port_callback(conn, error);
} else {
if (conn->auto_connect_stream) {
conn->pending = protocol_send_command(conn->server->channel, "PortForward",
"create", portcreate_cb, conn);
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, conn->id);
while (attr != NULL) {
write_stream(out, ',');
if (strcmp(attr->name, "RemotePort") == 0) {
json_write_string(out, "Port");
}
else {
json_write_string(out, attr->name);
}
write_stream(out, ':');
write_string(out, attr->value);
attr = attr->next;
}
if (conn->auto_connect_stream) {
write_stream(out, ',');
json_write_string(out, "AutoConnect");
write_stream(out, ':');
json_write_boolean(out, 1);
}
write_stream(out, '}');
write_stream(out, MARKER_EOA);
write_stream(out, MARKER_EOM);
}
else {
conn->pending = protocol_send_command(conn->server->channel, "Streams", "subscribe",
subscribe_cb, conn);
json_write_string(out, "PortForward");
write_stream(out, MARKER_EOA);
write_stream(out, MARKER_EOM);
}
}
}
static void command_resume(char * token, Channel * c) {
char id[256];
long mode;
long count;
Context * ctx;
int err = 0;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
mode = json_read_long(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
count = json_read_long(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (peek_stream(&c->inp) != MARKER_EOM) {
json_read_struct(&c->inp, resume_params_callback, &err);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
}
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if (err == 0) {
ctx = id2ctx(id);
assert(safe_event_list == NULL);
if (ctx == NULL) {
err = ERR_INV_CONTEXT;
}
else if (ctx->exited) {
err = ERR_ALREADY_EXITED;
}
else if (!ctx->intercepted) {
err = ERR_ALREADY_RUNNING;
}
else if (ctx->regs_error) {
err = ctx->regs_error;
}
else if (count != 1) {
err = EINVAL;
}
else if (mode == RM_RESUME || mode == RM_STEP_INTO) {
send_event_context_resumed(&c->bcg->out, ctx);
if (mode == RM_STEP_INTO) {
if (context_single_step(ctx) < 0) {
err = errno;
}
else {
ctx->pending_intercept = 1;
}
}
else if (context_continue(ctx) < 0) {
err = errno;
}
}
else {
err = EINVAL;
}
}
send_simple_result(c, token, err);
}
static void command_reset(char * token, Channel * c) {
CommandResetArgs args;
memset(&args, 0, sizeof(args));
json_read_string(&c->inp, args.id, sizeof(args.id));
json_test_char(&c->inp, MARKER_EOA);
json_read_string(&c->inp, args.type, sizeof(args.type));
json_test_char(&c->inp, MARKER_EOA);
json_read_struct(&c->inp, read_reset_params, &args.params);
json_test_char(&c->inp, MARKER_EOA);
json_test_char(&c->inp, MARKER_EOM);
strlcpy(args.token, token, sizeof(args.token));
cache_enter(command_reset_cache_client, c, &args, sizeof(args));
}
static void command_search(char * token, Channel * c) {
char id[256];
json_read_string(&c->inp, id, sizeof(id));
json_test_char(&c->inp, MARKER_EOA);
json_read_struct(&c->inp, read_filter_attrs, NULL);
json_test_char(&c->inp, MARKER_EOA);
json_test_char(&c->inp, MARKER_EOM);
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, ERR_UNSUPPORTED);
write_stringz(&c->out, "null");
write_stream(&c->out, MARKER_EOM);
}
static void command_disassemble(char * token, Channel * c) {
DisassembleCmdArgs args;
memset(&args, 0, sizeof(args));
json_read_string(&c->inp, args.id, sizeof(args.id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args.addr = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args.size = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
json_read_struct(&c->inp, read_disassembly_params, &args);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
strlcpy(args.token, token, sizeof(args.token));
cache_enter(disassemble_cache_client, c, &args, sizeof(DisassembleCmdArgs));
}
static void getconfig_cb(Channel * c, void * x, int error) {
Trap trap;
PortConnection * conn = (PortConnection *)x;
if (set_trap(&trap)) {
if (!error) {
error = read_errno(&c->inp);
json_read_struct(&c->inp, read_getconfig_struct, (void *)conn);
json_test_char(&c->inp, MARKER_EOA);
json_test_char(&c->inp, MARKER_EOM);
}
clear_trap(&trap);
}
else {
error = trap.error;
}
connect_port_callback(conn, error);
}
static void command_fsetstat(char * token, Channel * c) {
char id[256];
FileAttrs attrs;
OpenFileInfo * h = NULL;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
memset(&attrs, 0, sizeof(FileAttrs));
json_read_struct(&c->inp, read_file_attrs, &attrs);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
h = find_open_file_info(id);
if (h == NULL) {
reply_setstat(token, &c->out, EBADF);
}
else {
IORequest * req = create_io_request(token, h, REQ_FSETSTAT);
req->attrs = attrs;
post_io_requst(h);
}
}
