自学教程：C++ write_stringz函数代码示例

static void command_get_context(char * token, Channel * c) {    int err = 0;    char id[256];    Context * ctx = NULL;    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);    if (ctx == NULL) err = ERR_INV_CONTEXT;    else if (ctx->exited) err = ERR_ALREADY_EXITED;    if (err) {        write_stringz(&c->out, "R");        write_stringz(&c->out, token);        write_errno(&c->out, err);        write_stringz(&c->out, "null");        write_stream(&c->out, MARKER_EOM);    }    else {        /* Need to stop everything to access context properties.         * In particular, proc FS access can fail when process is running.         */        GetContextArgs * s = loc_alloc_zero(sizeof(GetContextArgs));        s->c = c;        stream_lock(c);        strcpy(s->token, token);        s->ctx = ctx;        context_lock(ctx);        id2pid(id, &s->parent);        post_safe_event(ctx->mem, event_get_context, s);    }}

void send_event_register_changed(const char * id) {    unsigned i;    Context * ctx = NULL;    int frame = STACK_NO_FRAME;    RegisterDefinition * def = NULL;    OutputStream * out = &broadcast_group->out;    id2register(id, &ctx, &frame, &def);    if (ctx == NULL) return;    for (i = 0; i < listener_cnt; i++) {        Listener * l = listeners + i;        if (l->func->register_changed == NULL) continue;        l->func->register_changed(ctx, frame, def, l->args);    }    if (frame >= 0 && frame == get_top_frame(ctx)) {        id = register2id(ctx, STACK_TOP_FRAME, def);    }    write_stringz(out, "E");    write_stringz(out, REGISTERS);    write_stringz(out, "registerChanged");    json_write_string(out, id);    write_stream(out, 0);    write_stream(out, MARKER_EOM);}

static void event_get_context(void * arg) {    GetContextArgs * s = (GetContextArgs *)arg;    Channel * c = s->c;    Context * ctx = s->ctx;    if (!is_stream_closed(c)) {        int err = 0;        write_stringz(&c->out, "R");        write_stringz(&c->out, s->token);        if (ctx->exited) err = ERR_ALREADY_EXITED;        write_errno(&c->out, err);        if (err == 0) {            write_context(&c->out, ctx, s->parent != 0);            write_stream(&c->out, 0);        }        else {            write_stringz(&c->out, "null");        }        write_stream(&c->out, MARKER_EOM);        flush_stream(&c->out);    }    stream_unlock(c);    context_unlock(ctx);    loc_free(s);}

static void command_get_context_cache_client(void * x) {    GetContextArgs * args = (GetContextArgs *)x;    Channel * c  = cache_channel();    Context * ctx = NULL;    int frame = STACK_NO_FRAME;    RegisterDefinition * reg_def = NULL;    Trap trap;    if (set_trap(&trap)) {        if (id2register(args->id, &ctx, &frame, &reg_def) < 0) exception(errno);        clear_trap(&trap);    }    cache_exit();    write_stringz(&c->out, "R");    write_stringz(&c->out, args->token);    write_errno(&c->out, trap.error);    if (reg_def != NULL) {        write_context(&c->out, args->id, ctx, frame, reg_def);    }    else {        write_stringz(&c->out, "null");    }    write_stream(&c->out, MARKER_EOM);}

static void command_write(char * token, Channel * c) {    char id[256];    long size;    int err = 0;    json_read_string(&c->inp, id, sizeof(id));    json_test_char(&c->inp, MARKER_EOA);    size = json_read_long(&c->inp);    json_test_char(&c->inp, MARKER_EOA);    if (virtual_stream_write(c, token, id, size, &c->inp) < 0) err = errno;    json_test_char(&c->inp, MARKER_EOA);    json_test_char(&c->inp, MARKER_EOM);    if (err != 0) {        /*         * Handle reply with an error. If none error was detected, the reply         * was sent back by virtual_stream_write() or delayed.         */        write_stringz(&c->out, "R");        write_stringz(&c->out, token);        write_errno(&c->out, err);        write_stream(&c->out, MARKER_EOM);    }}

int virtual_stream_eos(Channel * c, char * token, char * id) {    size_t done = 0;    WriteRequest * r = NULL;    int err = 0;    StreamClient * client = find_client(id, c);    if (client == NULL) err = errno;    if (!err && (client->stream->access & VS_ENABLE_REMOTE_WRITE) == 0) err = ERR_UNSUPPORTED;    if (!err && !list_is_empty(&client->write_requests)) r = (WriteRequest *)loc_alloc_zero(sizeof(WriteRequest));    if (!err && r == NULL && virtual_stream_add_data(client->stream, NULL, 0, &done, 1) < 0) err = errno;    if (r != NULL) {        list_init(&r->link_client);        r->client = client;        r->eos = 1;        strlcpy(r->token, token, sizeof(r->token));        list_add_last(&r->link_client, &client->write_requests);    }    else if (err == 0) {        write_stringz(&c->out, "R");        write_stringz(&c->out, token);        write_errno(&c->out, err);        write_stream(&c->out, MARKER_EOM);    }    if (err != 0) errno = err;    return err == 0 ? 0 : -1;}

static void command_set_signal_mask(char * token, Channel * c) {    int err = 0;    char id[256];    pid_t pid;    Context * ctx = NULL;    int dont_stop;    int dont_pass;    json_read_string(&c->inp, id, sizeof(id));    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    dont_stop = json_read_long(&c->inp);    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    dont_pass = json_read_long(&c->inp);    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);    pid = id2pid(id, NULL);    ctx = context_find_from_pid(pid);    if (ctx == NULL) {        err = ERR_INV_CONTEXT;    }    else {        ctx->sig_dont_stop = dont_stop;        ctx->sig_dont_pass = dont_pass;    }    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

static void command_signal(char * token, Channel * c) {    int err = 0;    char id[256];    int signal = 0;    pid_t pid, parent;    json_read_string(&c->inp, id, sizeof(id));    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    signal = (int)json_read_long(&c->inp);    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);    pid = id2pid(id, &parent);    write_stringz(&c->out, "R");    write_stringz(&c->out, token);#if defined(WIN32)    err = ENOSYS;#elif defined(_WRS_KERNEL)    if (kill(pid, signal) < 0) err = errno;#elif defined(__APPLE__)    if (kill(pid, signal) < 0) err = errno;#else    if (parent == 0) {        if (kill(pid, signal) < 0) err = errno;    }    else {        if (tkill(pid, signal) < 0) err = errno;    }#endif    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

static void command_terminate(char * token, Channel * c) {    int err = 0;    char id[256];    pid_t pid, parent;    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);    pid = id2pid(id, &parent);    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    if (parent != 0) {        err = ERR_INV_CONTEXT;    }    else {#if defined(WIN32)        HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);        if (h == NULL) {            err = ERR_INV_CONTEXT;        }        else {            TerminateProcess(h, 1);            CloseHandle(h);        }#else        if (kill(pid, SIGTERM) < 0) err = errno;#endif    }    write_errno(&c->out, err);    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 command_unsubscribe(char * token, Channel * c) {    char type[256];    int err = 0;    Subscription * s = NULL;    LINK * l;    json_read_string(&c->inp, type, sizeof(type));    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);    for (l = subscriptions.next; l != &subscriptions;) {        Subscription * h = all2subscription(l);        l = l->next;        if (h->channel == c && strcmp(type, h->type) == 0) {            s = h;            break;        }    }    if (s == NULL) err = ERR_INV_CONTEXT;    if (err == 0) delete_subscription(s);    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

static void command_set_win_size(char * token, Channel * c) {    int err = 0;    char id[256];    unsigned tid;    Terminal * term = NULL;    unsigned ws_col;    unsigned ws_row;    int changed = 0;    json_read_string(&c->inp, id, sizeof(id));    json_test_char(&c->inp, MARKER_EOA);    ws_col = json_read_ulong(&c->inp);    json_test_char(&c->inp, MARKER_EOA);    ws_row = json_read_ulong(&c->inp);    json_test_char(&c->inp, MARKER_EOA);    json_test_char(&c->inp, MARKER_EOM);    tid = id2tid(id);    if (tid == 0 || (term = find_terminal(tid)) == NULL) {        err = ERR_INV_CONTEXT;    }    else if (set_process_tty_win_size(term->prs, ws_col, ws_row, &changed) < 0) {        err = errno;    }    if (changed) send_event_terminal_win_size_changed(&term->bcg->out, term);    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

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_reset_cache_client(void * x) {    CommandResetArgs * args = (CommandResetArgs *)x;    Channel * c = cache_channel();    Context * ctx = id2ctx(args->id);    OutputStream * out = &c->out;    int err = 0;    if (ctx == NULL) err = ERR_INV_CONTEXT;    else if (ctx->exited) err = ERR_ALREADY_EXITED;    if (!err) {        Context * grp = get_reset_context(ctx);        ResetInfo * rst = find_reset(grp, args->type);        if (rst == NULL) err = set_errno(ERR_OTHER, "Unsupported reset type");        else if (rst->reset(ctx, &args->params) < 0) err = errno;    }    cache_exit();    while (args->params.list != NULL) {        ResetParameter * p = args->params.list;        args->params.list = p->next;        loc_free(p->name);        loc_free(p->value);        loc_free(p);    }    write_stringz(out, "R");    write_stringz(out, args->token);    write_errno(out, err);    write_stream(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);}

void send_event_memory_changed(Context * ctx, ContextAddress addr, unsigned long size) {    OutputStream * out = &broadcast_group->out;    if (!context_has_state(ctx) || is_intercepted(ctx)) {        write_stringz(out, "E");        write_stringz(out, MEMORY);        write_stringz(out, "memoryChanged");        json_write_string(out, ctx->id);        write_stream(out, 0);        /* <array of addres ranges> */        write_stream(out, '[');        write_stream(out, '{');        json_write_string(out, "addr");        write_stream(out, ':');        json_write_uint64(out, addr);        write_stream(out, ',');        json_write_string(out, "size");        write_stream(out, ':');        json_write_ulong(out, size);        write_stream(out, '}');        write_stream(out, ']');        write_stream(out, 0);        write_stream(out, MARKER_EOM);    }}

static void command_get_children(char * token, Channel * c) {    int err = 0;    char id[256];    Symbol sym;    Symbol * list = NULL;    int cnt = 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);    if (id2symbol(id, &sym) < 0) err = errno;    if (err == 0 && get_symbol_children(&sym, &list, &cnt) < 0) err = errno;    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    if (err == 0) {        int i;        write_stream(&c->out, '[');        for (i = 0; i < cnt; i++) {            if (i > 0) write_stream(&c->out, ',');            json_write_string(&c->out, symbol2id(list + i));        }        write_stream(&c->out, ']');        write_stream(&c->out, 0);    }    else {        write_stringz(&c->out, "null");    }    write_stream(&c->out, MARKER_EOM);    loc_free(list);}

static void command_get_array_type_cache_client(void * x) {    CommandGetArrayTypeArgs * args = (CommandGetArrayTypeArgs *)x;    Channel * c = cache_channel();    Symbol * sym = NULL;    Symbol * arr = NULL;    int err = 0;    if (id2symbol(args->id, &sym) < 0) err = errno;    if (err == 0 && get_array_symbol(sym, (ContextAddress)args->length, &arr) < 0) err = errno;    cache_exit();    write_stringz(&c->out, "R");    write_stringz(&c->out, args->token);    write_errno(&c->out, err);    if (err == 0) {        json_write_string(&c->out, symbol2id(arr));        write_stream(&c->out, 0);    }    else {        write_stringz(&c->out, "null");    }    write_stream(&c->out, MARKER_EOM);}

static void command_subscribe(char * token, Channel * c) {    char type[256];    int err = 0;    LINK * l;    json_read_string(&c->inp, type, sizeof(type));    if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);    if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);    for (l = subscriptions.next; l != &subscriptions;) {        Subscription * h = all2subscription(l);        l = l->next;        if (h->channel == c && strcmp(type, h->type) == 0) {            err = ERR_OTHER;            break;        }    }    if (err == 0) {        Subscription * s = loc_alloc_zero(sizeof(Subscription));        list_init(&s->link_all);        list_add_first(&s->link_all, &subscriptions);        strncpy(s->type, type, sizeof(s->type) - 1);        s->channel = c;    }    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

static void command_find_by_addr_cache_client(void * x) {    CommandFindByAddrArgs * args = (CommandFindByAddrArgs *)x;    Channel * c = cache_channel();    Context * ctx = NULL;    int frame = STACK_NO_FRAME;    Symbol * sym = NULL;    int err = 0;    if (id2frame(args->id, &ctx, &frame) < 0) ctx = id2ctx(args->id);    if (ctx == NULL) err = set_errno(ERR_INV_CONTEXT, args->id);    else if (ctx->exited) err = ERR_ALREADY_EXITED;    if (err == 0 && find_symbol_by_addr(ctx, frame, args->addr, &sym) < 0) err = errno;    list_cnt = 0;    if (err == 0) {        list_add(sym);        while (find_next_symbol(&sym) == 0) list_add(sym);        if (get_error_code(errno) != ERR_SYM_NOT_FOUND) err = errno;    }    cache_exit();    write_stringz(&c->out, "R");    write_stringz(&c->out, args->token);    write_errno(&c->out, err);    write_symbol_list(&c->out);    write_stream(&c->out, MARKER_EOM);}

static void command_find_in_scope_cache_client(void * x) {    CommandFindInScopeArgs * args = (CommandFindInScopeArgs *)x;    Channel * c = cache_channel();    Context * ctx = NULL;    int frame = STACK_NO_FRAME;    Symbol * scope = NULL;    Symbol * sym = NULL;    int err = 0;    if (id2frame(args->frame_id, &ctx, &frame) < 0) ctx = id2ctx(args->frame_id);    if (ctx == NULL) err = set_errno(ERR_INV_CONTEXT, args->frame_id);    else if (ctx->exited) err = ERR_ALREADY_EXITED;    if (err == 0 && args->scope_id[0] && id2symbol(args->scope_id, &scope) < 0) err = errno;    if (err == 0 && args->name == NULL) err = set_errno(EINVAL, "Symbol name must not be null");    if (err == 0 && find_symbol_in_scope(ctx, frame, args->ip, scope, args->name, &sym) < 0) err = errno;    list_cnt = 0;    if (err == 0) {        list_add(sym);        while (find_next_symbol(&sym) == 0) list_add(sym);        if (get_error_code(errno) != ERR_SYM_NOT_FOUND) err = errno;    }    cache_exit();    write_stringz(&c->out, "R");    write_stringz(&c->out, args->token);    write_errno(&c->out, err);    write_symbol_list(&c->out);    write_stream(&c->out, MARKER_EOM);    loc_free(args->name);}

static void command_get_children_cache_client(void * x) {    CommandGetChildrenArgs * args = (CommandGetChildrenArgs *)x;    Channel * c = cache_channel();    int err = 0;    Symbol * sym = NULL;    Symbol ** list = NULL;    int cnt = 0;    if (id2symbol(args->id, &sym) < 0) err = errno;    if (err == 0 && get_symbol_children(sym, &list, &cnt) < 0) err = errno;    cache_exit();    write_stringz(&c->out, "R");    write_stringz(&c->out, args->token);    write_errno(&c->out, err);    if (err == 0) {        int i;        write_stream(&c->out, '[');        for (i = 0; i < cnt; i++) {            if (i > 0) write_stream(&c->out, ',');            json_write_string(&c->out, symbol2id(list[i]));        }        write_stream(&c->out, ']');        write_stream(&c->out, 0);    }    else {        write_stringz(&c->out, "null");    }    write_stream(&c->out, MARKER_EOM);}

static void command_eos(char * token, Channel * c) {    char id[256];    StreamClient * client = NULL;    size_t done = 0;    WriteRequest * r = NULL;    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);    client = find_client(id, c);    if (client == NULL) err = errno;    if (!err && (client->stream->access & VS_ENABLE_REMOTE_WRITE) == 0) err = ERR_UNSUPPORTED;    if (!err && !list_is_empty(&client->write_requests)) r = loc_alloc_zero(sizeof(WriteRequest));    if (!err && r == NULL && virtual_stream_add_data(client->stream, NULL, 0, &done, 1) < 0) err = errno;    if (r != NULL) {        list_init(&r->link_client);        r->client = client;        r->eos = 1;        strncpy(r->token, token, sizeof(r->token) - 1);        list_add_last(&r->link_client, &client->write_requests);    }    else {        write_stringz(&c->out, "R");        write_stringz(&c->out, token);        write_errno(&c->out, err);        write_stream(&c->out, MARKER_EOM);    }}

static void command_attach(char * token, Channel * c) {    int err = 0;    char id[256];    pid_t pid, parent;    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);    pid = id2pid(id, &parent);    if (parent != 0) {        err = ERR_INV_CONTEXT;    }    else if (context_find_from_pid(pid) != NULL) {        err = ERR_ALREADY_ATTACHED;    }    else {        AttachDoneArgs * data = loc_alloc_zero(sizeof *data);        data->c = c;        strcpy(data->token, token);        if (context_attach(pid, attach_done, data, 0) == 0) {            stream_lock(c);            return;        }        err = errno;        loc_free(data);    }    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    write_stream(&c->out, MARKER_EOM);}

static void command_get_context(char * token, Channel * c) {    int err = 0;    char id[256];    int tid;    Terminal * term = NULL;    json_read_string(&c->inp, id, sizeof(id));    json_test_char(&c->inp, MARKER_EOA);    json_test_char(&c->inp, MARKER_EOM);    tid = id2tid(id);    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    if (tid == 0 || (term = find_terminal(tid)) == NULL) {        err = ERR_INV_CONTEXT;    }    write_errno(&c->out, err);    if (term != NULL) {        write_context(&c->out, tid);        write_stream(&c->out, 0);    }    else {        write_stringz(&c->out, "null");    }    write_stream(&c->out, MARKER_EOM);}

static void command_get_context(char * token, Channel * c) {    int err = 0;    char id[256];    Context * ctx = NULL;    json_read_string(&c->inp, id, sizeof(id));    json_test_char(&c->inp, MARKER_EOA);    json_test_char(&c->inp, MARKER_EOM);    ctx = id2ctx(id);    if (ctx == NULL || ctx->mem_access == 0) err = ERR_INV_CONTEXT;    else if (ctx->exited) err = ERR_ALREADY_EXITED;    write_stringz(&c->out, "R");    write_stringz(&c->out, token);    write_errno(&c->out, err);    if (err == 0) {        write_context(&c->out, ctx);    }    else {        write_string(&c->out, "null");    }    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 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);}