static void write_port_server_info(OutputStream * out, PortServer * server) {
PortAttribute * attr = server->redir_info ? server->redir_info->attrs : NULL;
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, server->id);
write_stream(out, ',');
json_write_string(out, "AutoConnect");
write_stream(out, ':');
json_write_boolean(out, server->auto_connect);
write_stream(out, ',');
json_write_string(out, "LocalPort");
write_stream(out, ':');
json_write_uint64(out, server->local_port);
if (server->is_udp) {
write_stream(out, ',');
json_write_string(out, "LocalPortIsUDP");
write_stream(out, ':');
json_write_boolean(out, server->is_udp);
}
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;
}
write_stream(out, '}');
}
static void write_context(OutputStream * out, int pid) {
Context * ctx = context_find_from_pid(pid);
ChildProcess * prs = find_process(pid);
write_stream(out, '{');
json_write_string(out, "Name");
write_stream(out, ':');
json_write_string(out, prs ? prs->name : pid2id(pid, 0));
write_stream(out, ',');
json_write_string(out, "CanTerminate");
write_stream(out, ':');
json_write_boolean(out, 1);
write_stream(out, ',');
if (ctx != NULL) {
json_write_string(out, "Attached");
write_stream(out, ':');
json_write_boolean(out, 1);
write_stream(out, ',');
}
if (prs != NULL) {
if (*prs->inp_id) {
json_write_string(out, "StdInID");
write_stream(out, ':');
json_write_string(out, prs->inp_id);
write_stream(out, ',');
}
if (*prs->out_id) {
json_write_string(out, "StdOutID");
write_stream(out, ':');
json_write_string(out, prs->out_id);
write_stream(out, ',');
}
if (*prs->err_id) {
json_write_string(out, "StdErrID");
write_stream(out, ':');
json_write_string(out, prs->err_id);
write_stream(out, ',');
}
}
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, pid2id(pid, 0));
write_stream(out, '}');
}
static void write_port_server_info(OutputStream * out, PortServer * server) {
PortAttribute * attr = server->attrs;
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, server->id);
write_stream(out, ',');
json_write_string(out, "AutoConnect");
write_stream(out, ':');
json_write_boolean(out, server->auto_connect);
write_stream(out, ',');
if (server->is_udp) json_write_string(out, "UdpPort");
else json_write_string(out, "TcpPort");
write_stream(out, ':');
json_write_ulong(out, server->local_port);
while (attr != NULL) {
if (strcmp(attr->name, "AutoConnect") != 0) {
write_stream(out, ',');
json_write_string(out, attr->name);
write_stream(out, ':');
write_string(out, attr->value);
}
attr = attr->next;
}
write_stream(out, '}');
}
static void command_read(char * token, Channel * c) {
char id[256];
size_t size;
int err = 0;
json_read_string(&c->inp, id, sizeof(id));
json_test_char(&c->inp, MARKER_EOA);
size = json_read_ulong(&c->inp);
json_test_char(&c->inp, MARKER_EOA);
json_test_char(&c->inp, MARKER_EOM);
if (virtual_stream_read(c, token, id, size) < 0) err = errno;
if (err != 0) {
/*
* Handle reply with an error. If none error was detected, the reply
* was sent back by virtual_stream_read() or delayed.
*/
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_stringz(&c->out, "null");
write_errno(&c->out, err);
json_write_long(&c->out, 0);
write_stream(&c->out, 0);
json_write_boolean(&c->out, 0);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
}
}
static void command_get_state(char * token, Channel * c) {
char id[256];
Context * ctx;
int err = 0;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
ctx = id2ctx(id);
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
if (ctx == NULL) err = ERR_INV_CONTEXT;
else if (ctx->exited) err = ERR_ALREADY_EXITED;
write_errno(&c->out, err);
json_write_boolean(&c->out, ctx != NULL && ctx->intercepted);
write_stream(&c->out, 0);
if (err) {
write_stringz(&c->out, "0");
write_stringz(&c->out, "null");
write_stringz(&c->out, "null");
}
else {
write_context_state(&c->out, ctx);
}
write_stream(&c->out, MARKER_EOM);
}
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 send_read_reply(StreamClient * client, char * token, size_t size) {
VirtualStream * stream = client->stream;
Channel * c = client->channel;
unsigned lost = 0;
unsigned read1 = 0;
unsigned read2 = 0;
int eos = 0;
char * data1 = NULL;
char * data2 = NULL;
unsigned pos = 0;
unsigned len = (stream->buf_inp + stream->buf_len - stream->buf_out) % stream->buf_len;
assert(len > 0 || stream->eos);
assert(client->pos <= stream->pos);
if ((uint64_t)len < stream->pos - client->pos) {
lost = (long)(stream->pos - client->pos - len);
}
else {
len = (unsigned)(stream->pos - client->pos);
}
pos = (stream->buf_inp + stream->buf_len - len) % stream->buf_len;
if (len > size) len = size;
data1 = stream->buf + pos;
if (pos + len <= stream->buf_len) {
read1 = len;
}
else {
read1 = stream->buf_len - pos;
data2 = stream->buf;
read2 = len - read1;
}
assert(read1 + read2 == len);
client->pos += lost + read1 + read2;
assert(client->pos <= stream->pos);
if (client->pos == stream->pos && stream->eos) eos = 1;
assert(eos || lost + read1 + read2 > 0);
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
if (read1 + read2 > 0) {
JsonWriteBinaryState state;
json_write_binary_start(&state, &c->out, read1 + read2);
json_write_binary_data(&state, data1, read1);
json_write_binary_data(&state, data2, read2);
json_write_binary_end(&state);
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_errno(&c->out, 0);
json_write_long(&c->out, lost);
write_stream(&c->out, 0);
json_write_boolean(&c->out, eos);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
}
static void write_boolean_member(OutputStream * out, const char * name, int val) {
/* For this service FALSE is same as absence of the member */
if (!val) return;
write_stream(out, ',');
json_write_string(out, name);
write_stream(out, ':');
json_write_boolean(out, 1);
}
static void reply_read(char * token, OutputStream * out, int err, void * buf, unsigned len, int eof) {
write_stringz(out, "R");
write_stringz(out, token);
json_write_binary(out, buf, len);
write_stream(out, 0);
write_fs_errno(out, err);
json_write_boolean(out, eof);
write_stream(out, 0);
write_stream(out, MARKER_EOM);
}
static void command_read(char * token, Channel * c) {
char id[256];
size_t size = 0;
StreamClient * client = NULL;
int err = 0;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
size = json_read_ulong(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
client = find_client(id, c);
if (client == NULL) err = errno;
if (!err && (client->stream->access & VS_ENABLE_REMOTE_READ) == 0) err = ERR_UNSUPPORTED;
if (err == 0) {
VirtualStream * stream = client->stream;
if (client->pos == stream->pos && !stream->eos) {
ReadRequest * r = loc_alloc_zero(sizeof(ReadRequest));
list_init(&r->link_client);
r->client = client;
r->size = size;
strncpy(r->token, token, sizeof(r->token) - 1);
list_add_last(&r->link_client, &client->read_requests);
}
else {
assert(list_is_empty(&client->read_requests));
assert(client->channel == c);
send_read_reply(client, token, size);
advance_stream_buffer(stream);
}
}
else {
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_stringz(&c->out, "null");
write_errno(&c->out, err);
json_write_long(&c->out, 0);
write_stream(&c->out, 0);
json_write_boolean(&c->out, 0);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
}
}
static void delete_read_request(ReadRequest * r) {
Channel * c = r->client->channel;
Trap trap;
if (set_trap(&trap)) {
write_stringz(&c->out, "R");
write_stringz(&c->out, r->token);
write_stringz(&c->out, "null");
write_errno(&c->out, ERR_COMMAND_CANCELLED);
json_write_long(&c->out, 0);
write_stream(&c->out, 0);
json_write_boolean(&c->out, 1);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
clear_trap(&trap);
}
else {
trace(LOG_ALWAYS, "Exception handling pending stream read command: %d %s",
trap.error, errno_to_str(trap.error));
}
list_remove(&r->link_client);
loc_free(r);
}
static void command_readdir(char * token, Channel * c) {
char id[256];
OpenFileInfo * h = NULL;
int err = 0;
int eof = 0;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
h = find_open_file_info(id);
if (h == NULL || h->dir == NULL) {
write_stringz(&c->out, "null");
err = EBADF;
}
else {
int cnt = 0;
write_stream(&c->out, '[');
while (cnt < 64) {
struct dirent * e;
char path[FILE_PATH_SIZE];
struct stat st;
FileAttrs attrs;
errno = 0;
e = readdir(h->dir);
if (e == NULL) {
err = errno;
if (err == 0) eof = 1;
break;
}
if (strcmp(e->d_name, ".") == 0) continue;
if (strcmp(e->d_name, "..") == 0) continue;
if (cnt > 0) write_stream(&c->out, ',');
write_stream(&c->out, '{');
json_write_string(&c->out, "FileName");
write_stream(&c->out, ':');
json_write_string(&c->out, e->d_name);
memset(&st, 0, sizeof(st));
snprintf(path, sizeof(path), "%s/%s", h->path, e->d_name);
if (stat(path, &st) == 0) {
fill_attrs(&attrs, &st);
write_stream(&c->out, ',');
json_write_string(&c->out, "Attrs");
write_stream(&c->out, ':');
write_file_attrs(&c->out, &attrs);
}
write_stream(&c->out, '}');
cnt++;
}
write_stream(&c->out, ']');
write_stream(&c->out, 0);
}
write_fs_errno(&c->out, err);
json_write_boolean(&c->out, eof);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
}
static void write_context(OutputStream * out, Context * ctx) {
assert(!ctx->exited);
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, ctx->id);
if (ctx->parent != NULL) {
write_stream(out, ',');
json_write_string(out, "ParentID");
write_stream(out, ':');
json_write_string(out, ctx->parent->id);
}
write_stream(out, ',');
json_write_string(out, "ProcessID");
write_stream(out, ':');
json_write_string(out, context_get_group(ctx, CONTEXT_GROUP_PROCESS)->id);
if (ctx->name != NULL) {
write_stream(out, ',');
json_write_string(out, "Name");
write_stream(out, ':');
json_write_string(out, ctx->name);
}
write_stream(out, ',');
json_write_string(out, "BigEndian");
write_stream(out, ':');
json_write_boolean(out, ctx->big_endian);
if (ctx->mem_access) {
int cnt = 0;
write_stream(out, ',');
json_write_string(out, "AddressSize");
write_stream(out, ':');
json_write_ulong(out, context_word_size(ctx));
write_stream(out, ',');
json_write_string(out, "AccessTypes");
write_stream(out, ':');
write_stream(out, '[');
if (ctx->mem_access & MEM_ACCESS_INSTRUCTION) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "instruction");
}
if (ctx->mem_access & MEM_ACCESS_DATA) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "data");
}
if (ctx->mem_access & MEM_ACCESS_IO) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "io");
}
if (ctx->mem_access & MEM_ACCESS_USER) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "user");
}
if (ctx->mem_access & MEM_ACCESS_SUPERVISOR) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "supervisor");
}
if (ctx->mem_access & MEM_ACCESS_HYPERVISOR) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "hypervisor");
}
if (ctx->mem_access & MEM_ACCESS_VIRTUAL) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "virtual");
}
if (ctx->mem_access & MEM_ACCESS_PHYSICAL) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "physical");
}
if (ctx->mem_access & MEM_ACCESS_CACHE) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "cache");
}
if (ctx->mem_access & MEM_ACCESS_TLB) {
if (cnt++) write_stream(out, ',');
json_write_string(out, "tlb");
}
write_stream(out, ']');
}
write_stream(out, '}');
}
static void command_get_location_info_cache_client(void * x) {
CommandGetLocationInfo * args = (CommandGetLocationInfo *)x;
Channel * c = cache_channel();
LocationInfo * info = NULL;
Context * ctx = NULL;
int frame = STACK_NO_FRAME;
Symbol * sym = NULL;
int err = 0;
if (id2symbol(args->id, &sym) < 0) err = errno;
else if (get_location_info(sym, &info) < 0) err = errno;
else if (get_symbol_frame(sym, &ctx, &frame) < 0) err = errno;
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (info == NULL) {
write_stringz(&c->out, "null");
}
else {
write_stream(&c->out, '{');
json_write_string(&c->out, "BigEndian");
write_stream(&c->out, ':');
json_write_boolean(&c->out, info->big_endian);
write_stream(&c->out, ',');
json_write_string(&c->out, "ValueCmds");
write_stream(&c->out, ':');
write_commands(&c->out, ctx, info->value_cmds.cmds, info->value_cmds.cnt);
if (info->args_cnt) {
write_stream(&c->out, ',');
json_write_string(&c->out, "ArgCnt");
write_stream(&c->out, ':');
json_write_ulong(&c->out, info->args_cnt);
}
if (info->code_size) {
write_stream(&c->out, ',');
json_write_string(&c->out, "CodeAddr");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->code_addr);
write_stream(&c->out, ',');
json_write_string(&c->out, "CodeSize");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->code_size);
}
if (info->discr_cnt > 0) {
unsigned i;
write_stream(&c->out, ',');
json_write_string(&c->out, "Discriminant");
write_stream(&c->out, ':');
write_stream(&c->out, '[');
for (i = 0; i < info->discr_cnt; i++) {
DiscriminantRange * r = info->discr_lst + i;
if (i > 0) write_stream(&c->out, ',');
if (r->x == r->y) {
json_write_int64(&c->out, r->x);
}
else {
write_stream(&c->out, '{');
json_write_string(&c->out, "X");
write_stream(&c->out, ':');
json_write_int64(&c->out, r->x);
write_stream(&c->out, ',');
json_write_string(&c->out, "Y");
write_stream(&c->out, ':');
json_write_int64(&c->out, r->y);
write_stream(&c->out, '}');
}
}
write_stream(&c->out, ']');
}
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
static void write_commands(OutputStream * out, Context * ctx, LocationExpressionCommand * cmds, unsigned cnt) {
if (cmds != NULL) {
unsigned i;
write_stream(out, '[');
for (i = 0; i < cnt; i++) {
LocationExpressionCommand * cmd = cmds + i;
if (i > 0) write_stream(out, ',');
json_write_long(out, cmd->cmd);
switch (cmd->cmd) {
case SFT_CMD_NUMBER:
write_stream(out, ',');
json_write_int64(out, cmd->args.num);
break;
case SFT_CMD_ARG:
case SFT_CMD_SET_ARG:
write_stream(out, ',');
json_write_ulong(out, cmd->args.arg_no);
break;
case SFT_CMD_RD_REG:
case SFT_CMD_WR_REG:
write_stream(out, ',');
json_write_string(out, register2id(ctx, STACK_NO_FRAME, cmd->args.reg));
break;
case SFT_CMD_RD_MEM:
case SFT_CMD_WR_MEM:
case SFT_CMD_LOAD:
write_stream(out, ',');
json_write_ulong(out, cmd->args.mem.size);
write_stream(out, ',');
json_write_boolean(out, cmd->args.mem.big_endian);
break;
case SFT_CMD_LOCATION:
write_stream(out, ',');
json_write_binary(out, cmd->args.loc.code_addr, cmd->args.loc.code_size);
write_stream(out, ',');
write_stream(out, '{');
json_write_string(out, "Machine");
write_stream(out, ':');
json_write_long(out, cmd->args.loc.reg_id_scope.machine);
write_stream(out, ',');
if (cmd->args.loc.reg_id_scope.os_abi) {
json_write_string(out, "ABI");
write_stream(out, ':');
json_write_long(out, cmd->args.loc.reg_id_scope.os_abi);
write_stream(out, ',');
}
if (cmd->args.loc.reg_id_scope.fp_abi) {
json_write_string(out, "FPABI");
write_stream(out, ':');
json_write_long(out, cmd->args.loc.reg_id_scope.fp_abi);
write_stream(out, ',');
}
json_write_string(out, "ELF64");
write_stream(out, ':');
json_write_boolean(out, cmd->args.loc.reg_id_scope.elf64);
write_stream(out, ',');
json_write_string(out, "RegIdType");
write_stream(out, ':');
json_write_long(out, cmd->args.loc.reg_id_scope.id_type);
write_stream(out, ',');
json_write_string(out, "AddrSize");
write_stream(out, ':');
json_write_long(out, cmd->args.loc.addr_size);
write_stream(out, ',');
json_write_string(out, "BigEndian");
write_stream(out, ':');
json_write_boolean(out, cmd->args.loc.reg_id_scope.big_endian);
write_stream(out, '}');
break;
case SFT_CMD_PIECE:
write_stream(out, ',');
json_write_ulong(out, cmd->args.piece.bit_offs);
write_stream(out, ',');
json_write_ulong(out, cmd->args.piece.bit_size);
write_stream(out, ',');
if (cmd->args.piece.reg == NULL) write_string(out, "null");
else json_write_string(out, register2id(ctx, STACK_NO_FRAME, cmd->args.piece.reg));
write_stream(out, ',');
if (cmd->args.piece.value == NULL) write_string(out, "null");
else json_write_binary(out, cmd->args.piece.value, (cmd->args.piece.bit_size + 7) / 8);
break;
}
}
write_stream(out, ']');
}
else {
write_string(out, "null");
}
}
static void command_get_context_cache_client(void * x) {
CommandGetContextArgs * args = (CommandGetContextArgs *)x;
Channel * c = cache_channel();
int err = 0;
Symbol * sym = NULL;
char * owner = NULL;
char * name = NULL;
int update_policy = 0;
int sym_class = SYM_CLASS_UNKNOWN;
int type_class = TYPE_CLASS_UNKNOWN;
Symbol * type = NULL;
Symbol * base = NULL;
Symbol * index = NULL;
Symbol * container = NULL;
int has_size = 0;
int has_length = 0;
int has_lower_bound = 0;
int has_offset = 0;
int has_address = 0;
int has_frame = 0;
int big_endian = 0;
ContextAddress size = 0;
ContextAddress length = 0;
int64_t lower_bound = 0;
ContextAddress offset = 0;
ContextAddress address = 0;
RegisterDefinition * reg = NULL;
SYM_FLAGS flags = 0;
void * value = NULL;
size_t value_size = 0;
Context * ctx = NULL;
int frame = STACK_NO_FRAME;
SymbolProperties props;
memset(&props, 0, sizeof(props));
if (id2symbol(args->id, &sym) < 0) err = errno;
if (err == 0) {
get_symbol_class(sym, &sym_class);
get_symbol_update_policy(sym, &owner, &update_policy);
get_symbol_name(sym, &name);
get_symbol_type_class(sym, &type_class);
get_symbol_type(sym, &type);
get_symbol_base_type(sym, &base);
get_symbol_index_type(sym, &index);
get_symbol_container(sym, &container);
has_frame = get_symbol_frame(sym, &ctx, &frame) == 0;
has_size = get_symbol_size(sym, &size) == 0;
if (type_class == TYPE_CLASS_ARRAY) {
has_length = get_symbol_length(sym, &length) == 0;
if (has_length) has_lower_bound = get_symbol_lower_bound(sym, &lower_bound) == 0;
}
if (sym_class == SYM_CLASS_REFERENCE || sym_class == SYM_CLASS_FUNCTION ||
sym_class == SYM_CLASS_VALUE || sym_class == SYM_CLASS_TYPE ||
sym_class == SYM_CLASS_VARIANT_PART) {
LocationInfo * loc_info = NULL;
if (has_frame && get_location_info(sym, &loc_info) == 0) {
LocationExpressionState * state = NULL;
if (loc_info->args_cnt == 0) {
/* Absolute location */
state = evaluate_location(ctx, frame, loc_info);
if (state != NULL) {
if (state->stk_pos == 1) {
address = (ContextAddress)state->stk[0];
has_address = 1;
}
if (state->pieces_cnt == 1 && state->pieces->reg != NULL &&
state->pieces->reg->size == state->pieces->size) {
reg = state->pieces->reg;
}
if (state->pieces_cnt > 0) {
Trap trap;
if (set_trap(&trap)) {
read_location_pieces(state->ctx, state->stack_frame,
state->pieces, state->pieces_cnt, loc_info->big_endian, &value, &value_size);
big_endian = loc_info->big_endian;
clear_trap(&trap);
}
}
}
}
else if (loc_info->args_cnt == 1) {
/* Relative location */
state = evaluate_location(ctx, frame, loc_info);
if (state != NULL && state->stk_pos == 1) {
offset = (ContextAddress)state->stk[0];
has_offset = 1;
}
}
}
}
get_symbol_flags(sym, &flags);
get_symbol_props(sym, &props);
}
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (err == 0) {
write_stream(&c->out, '{');
json_write_string(&c->out, "ID");
write_stream(&c->out, ':');
json_write_string(&c->out, args->id);
write_stream(&c->out, ',');
if (owner != NULL) {
json_write_string(&c->out, "OwnerID");
write_stream(&c->out, ':');
json_write_string(&c->out, owner);
write_stream(&c->out, ',');
json_write_string(&c->out, "UpdatePolicy");
write_stream(&c->out, ':');
json_write_long(&c->out, update_policy);
write_stream(&c->out, ',');
}
if (name != NULL) {
json_write_string(&c->out, "Name");
write_stream(&c->out, ':');
json_write_string(&c->out, name);
write_stream(&c->out, ',');
}
if (type_class != TYPE_CLASS_UNKNOWN) {
json_write_string(&c->out, "TypeClass");
write_stream(&c->out, ':');
json_write_long(&c->out, type_class);
write_stream(&c->out, ',');
}
if (type != NULL) {
json_write_string(&c->out, "TypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(type));
write_stream(&c->out, ',');
}
if (base != NULL) {
json_write_string(&c->out, "BaseTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(base));
write_stream(&c->out, ',');
}
if (index != NULL) {
json_write_string(&c->out, "IndexTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(index));
write_stream(&c->out, ',');
}
if (container != NULL) {
json_write_string(&c->out, "ContainerID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(container));
write_stream(&c->out, ',');
}
if (has_size) {
json_write_string(&c->out, "Size");
write_stream(&c->out, ':');
json_write_uint64(&c->out, size);
write_stream(&c->out, ',');
}
if (has_length) {
json_write_string(&c->out, "Length");
write_stream(&c->out, ':');
json_write_uint64(&c->out, length);
write_stream(&c->out, ',');
if (has_lower_bound) {
json_write_string(&c->out, "LowerBound");
write_stream(&c->out, ':');
json_write_int64(&c->out, lower_bound);
write_stream(&c->out, ',');
json_write_string(&c->out, "UpperBound");
write_stream(&c->out, ':');
json_write_int64(&c->out, lower_bound + (int64_t)length - 1);
write_stream(&c->out, ',');
}
}
if (has_offset) {
json_write_string(&c->out, "Offset");
write_stream(&c->out, ':');
json_write_uint64(&c->out, offset);
write_stream(&c->out, ',');
}
if (has_address) {
json_write_string(&c->out, "Address");
write_stream(&c->out, ':');
json_write_uint64(&c->out, address);
write_stream(&c->out, ',');
}
if (reg != NULL && has_frame) {
json_write_string(&c->out, "Register");
write_stream(&c->out, ':');
json_write_string(&c->out, register2id(ctx, frame, reg));
write_stream(&c->out, ',');
}
if (flags) {
json_write_string(&c->out, "Flags");
write_stream(&c->out, ':');
json_write_long(&c->out, flags);
write_stream(&c->out, ',');
}
if (props.binary_scale != 0) {
json_write_string(&c->out, "BinaryScale");
write_stream(&c->out, ':');
json_write_long(&c->out, props.binary_scale);
write_stream(&c->out, ',');
}
if (props.decimal_scale != 0) {
json_write_string(&c->out, "DecimalScale");
write_stream(&c->out, ':');
json_write_long(&c->out, props.decimal_scale);
write_stream(&c->out, ',');
}
if (props.bit_stride != 0) {
json_write_string(&c->out, "BitStride");
write_stream(&c->out, ':');
json_write_ulong(&c->out, props.bit_stride);
write_stream(&c->out, ',');
}
if (props.local_entry_offset != 0) {
json_write_string(&c->out, "LocalEntryOffset");
write_stream(&c->out, ':');
json_write_ulong(&c->out, props.local_entry_offset);
write_stream(&c->out, ',');
}
if (value != NULL) {
json_write_string(&c->out, "Value");
write_stream(&c->out, ':');
json_write_binary(&c->out, value, value_size);
write_stream(&c->out, ',');
if (big_endian) {
json_write_string(&c->out, "BigEndian");
write_stream(&c->out, ':');
json_write_boolean(&c->out, 1);
write_stream(&c->out, ',');
}
}
if (has_frame && frame != STACK_NO_FRAME) {
json_write_string(&c->out, "Frame");
write_stream(&c->out, ':');
json_write_long(&c->out, frame);
write_stream(&c->out, ',');
}
json_write_string(&c->out, "Class");
write_stream(&c->out, ':');
json_write_long(&c->out, sym_class);
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_stream(&c->out, MARKER_EOM);
}
static void write_context(OutputStream * out, Context * ctx, int is_thread) {
assert(!ctx->exited);
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, is_thread ? thread_id(ctx) : container_id(ctx));
if (is_thread) {
write_stream(out, ',');
json_write_string(out, "ParentID");
write_stream(out, ':');
json_write_string(out, container_id(ctx));
}
#if !defined(_WRS_KERNEL)
write_stream(out, ',');
json_write_string(out, "ProcessID");
write_stream(out, ':');
json_write_string(out, pid2id(ctx->mem, 0));
#endif
#if !defined(WIN32) && !defined(_WRS_KERNEL)
if (!ctx->exiting && !is_thread) {
write_stream(out, ',');
json_write_string(out, "File");
write_stream(out, ':');
json_write_string(out, get_executable(ctx->pid));
}
#endif
if (is_thread) {
write_stream(out, ',');
json_write_string(out, "CanSuspend");
write_stream(out, ':');
json_write_boolean(out, 1);
write_stream(out, ',');
json_write_string(out, "CanResume");
write_stream(out, ':');
json_write_long(out, (1 << RM_RESUME) | (1 << RM_STEP_INTO));
write_stream(out, ',');
json_write_string(out, "HasState");
write_stream(out, ':');
json_write_boolean(out, 1);
}
#ifdef WIN32
if (!is_thread)
#endif
{
write_stream(out, ',');
json_write_string(out, "CanTerminate");
write_stream(out, ':');
json_write_boolean(out, 1);
}
write_stream(out, '}');
}