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_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_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 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_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_close(char * token, Channel * c) { char id[256]; OpenFileInfo * h = 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); h = find_open_file_info(id); if (h == NULL) { err = EBADF; } else if (h->dir != NULL) { if (closedir(h->dir) < 0) { err = errno; } else { delete_open_file_info(h); } } else { IORequest * req = create_io_request(token, h, REQ_CLOSE); req->info.type = AsyncReqClose; req->info.u.fio.fd = h->file; post_io_requst(h); return; } reply_close(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_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_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 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_read(char * token, Channel * c) { char id[256]; OpenFileInfo * h = NULL; int64_t offset; unsigned long len; json_read_string(&c->inp, id, sizeof(id)); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); offset = json_read_int64(&c->inp); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); len = 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); h = find_open_file_info(id); if (h == NULL) { reply_read(token, &c->out, EBADF, NULL, 0, 0); } else { IORequest * req = create_io_request(token, h, REQ_READ); if (offset < 0) { req->info.type = AsyncReqRead; } else { req->info.type = AsyncReqSeekRead; req->info.u.fio.offset = (off_t)offset; } req->info.u.fio.fd = h->file; req->info.u.fio.bufp = loc_alloc(len); req->info.u.fio.bufsz = len; post_io_requst(h); } }
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_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_suspend(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); if (ctx == NULL) { err = ERR_INV_CONTEXT; } else if (ctx->exited) { err = ERR_ALREADY_EXITED; } else if (ctx->intercepted) { err = ERR_ALREADY_STOPPED; } else if (ctx->stopped) { send_event_context_suspended(&c->bcg->out, ctx); } else { ctx->pending_intercept = 1; if (context_stop(ctx) < 0) err = errno; } send_simple_result(c, token, err); }
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 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); } }
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_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_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_get_signal_list(char * token, Channel * c) { int err = 0; char id[256]; pid_t pid; 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, NULL); write_stringz(&c->out, "R"); write_stringz(&c->out, token); /* pid is ignored, same signal list for all */ write_errno(&c->out, err); if (err) { write_stringz(&c->out, "null"); } else { int i = 0; int n = 0; write_stream(&c->out, '['); for (i = 0; i < 32; i++) { char * name = signal_name(i); char * desc = signal_description(i); if (name != NULL || desc != NULL) { if (n > 0) write_stream(&c->out, ','); write_stream(&c->out, '{'); json_write_string(&c->out, "Index"); write_stream(&c->out, ':'); json_write_long(&c->out, i); if (name != NULL) { write_stream(&c->out, ','); json_write_string(&c->out, "Name"); write_stream(&c->out, ':'); json_write_string(&c->out, name); } if (desc != NULL) { write_stream(&c->out, ','); json_write_string(&c->out, "Description"); write_stream(&c->out, ':'); json_write_string(&c->out, desc); } write_stream(&c->out, ','); json_write_string(&c->out, "Code"); write_stream(&c->out, ':'); json_write_ulong(&c->out, signal_code(i)); write_stream(&c->out, '}'); n++; } } write_stream(&c->out, ']'); write_stream(&c->out, 0); } write_stream(&c->out, MARKER_EOM); }
static void command_get_capabilities(char * token, Channel * c) { GetCapabilitiesCmdArgs args; json_read_string(&c->inp, args.id, sizeof(args.id)); 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(command_get_capabilities_cache_client, c, &args, sizeof(args)); }
static void command_terminate(char * token, Channel * c) { char id[256]; 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); if (terminate_debug_context(c->bcg, id2ctx(id)) != 0) err = errno; send_simple_result(c, token, err); }
static void command_get_children(char * token, Channel * c) { char id[256]; 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); write_errno(&c->out, 0); write_stream(&c->out, '['); if (id[0] == 0) { LINK * qp; int cnt = 0; for (qp = context_root.next; qp != &context_root; qp = qp->next) { Context * ctx = ctxl2ctxp(qp); if (ctx->exited) continue; if (ctx->parent != NULL) continue; if (cnt > 0) write_stream(&c->out, ','); json_write_string(&c->out, container_id(ctx)); cnt++; } } else if (id[0] == 'P') { LINK * qp; int cnt = 0; pid_t ppd = 0; Context * parent = id2ctx(id); id2pid(id, &ppd); if (parent != NULL && parent->parent == NULL && ppd == 0) { if (!parent->exited && context_has_state(parent)) { if (cnt > 0) write_stream(&c->out, ','); json_write_string(&c->out, thread_id(parent)); cnt++; } for (qp = parent->children.next; qp != &parent->children; qp = qp->next) { Context * ctx = cldl2ctxp(qp); assert(!ctx->exited); assert(ctx->parent == parent); if (cnt > 0) write_stream(&c->out, ','); json_write_string(&c->out,thread_id(ctx)); cnt++; } } } write_stream(&c->out, ']'); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); }
static void command_write(char * token, Channel * c) { char id[256]; OpenFileInfo * h = NULL; int64_t offset; unsigned long len = 0; JsonReadBinaryState state; static size_t buf_size = 0; static char * buf = NULL; json_read_string(&c->inp, id, sizeof(id)); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); offset = json_read_int64(&c->inp); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); json_read_binary_start(&state, &c->inp); h = find_open_file_info(id); for (;;) { int rd; if (buf_size < len + BUF_SIZE) { buf_size += BUF_SIZE; buf = loc_realloc(buf, buf_size); } rd = json_read_binary_data(&state, buf + len, buf_size - len); if (rd == 0) break; len += rd; } json_read_binary_end(&state); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); if (h == NULL) { reply_write(token, &c->out, EBADF); } else { IORequest * req = create_io_request(token, h, REQ_WRITE); if (offset < 0) { req->info.type = AsyncReqWrite; } else { req->info.type = AsyncReqSeekWrite; req->info.u.fio.offset = (off_t)offset; } req->info.u.fio.fd = h->file; req->info.u.fio.bufp = loc_alloc(len); req->info.u.fio.bufsz = len; memcpy(req->info.u.fio.bufp, buf, len); post_io_requst(h); } }
static void command_lstat(char * token, Channel * c) { char path[FILE_PATH_SIZE]; struct stat buf; int err = 0; read_path(&c->inp, path, sizeof(path)); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); memset(&buf, 0, sizeof(buf)); if (lstat(path, &buf) < 0) err = errno; reply_stat(token, &c->out, err, &buf); }
static void command_rmdir(char * token, Channel * c) { char path[FILE_PATH_SIZE]; int err = 0; read_path(&c->inp, path, sizeof(path)); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); if (rmdir(path) < 0) err = errno; write_stringz(&c->out, "R"); write_stringz(&c->out, token); write_fs_errno(&c->out, err); write_stream(&c->out, MARKER_EOM); }
static void channel_send_command_cb(Channel * c, void * client_data, int error) { struct channel_extra *ce = (struct channel_extra *)c->client_data; struct command_extra *cmd = (struct command_extra *)client_data; lua_State *L = ce->L; InputStream * inp = &c->inp; luaL_Buffer msg; int ch; lua_rawgeti(L, LUA_REGISTRYINDEX, cmd->result_cbrefp->ref); if(!error) { luaL_buffinit(L, &msg); while((ch = read_stream(inp)) >= 0) { luaL_addchar(&msg, ch); } luaL_pushresult(&msg); lua_pushnil(L); trace(LOG_LUA, "lua_channel_send_command_reply %p %d %s", c, cmd->result_cbrefp->ref, lua_tostring(L, -2)); } else { lua_pushnil(L); lua_pushstring(L, errno_to_str(error)); trace(LOG_LUA, "lua_channel_send_command_reply %p %d error %d", c, cmd->result_cbrefp->ref, error); } if(lua_pcall(L, 2, 0, 0) != 0) { fprintf(stderr, "%s\n", lua_tostring(L,1)); exit(1); } luaref_owner_free(L, cmd); }
static void port_server_cmd_delete(char * token, Channel * c) { char id[256]; int err = 0; PortServer * server; 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 ((server = find_port_server(id)) == NULL) err = ERR_INV_CONTEXT; else port_server_shutdown(server); write_stringz(&c->out, "R"); write_stringz(&c->out, token); write_errno(&c->out, err); write_stream(&c->out, MARKER_EOM); }
int main(int argc, char *argv[]) /* simple TCP client */ { struct sockaddr_in serv; char request[REQUEST], reply[REPLY]; int sockfd, n; if (argc != 2) err_quit("usage: tcpcli <IP address of server>"); if ( (sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) err_sys("socket error"); memset(&serv, 0, sizeof(serv)); serv.sin_family = AF_INET; serv.sin_addr.s_addr = inet_addr(argv[1]); serv.sin_port = htons(TCP_SERV_PORT); if (connect(sockfd, (SA) &serv, sizeof(serv)) < 0) err_sys("connect error"); /* form request[] ... */ if (write(sockfd, request, REQUEST) != REQUEST) err_sys("write error"); if (shutdown(sockfd, 1) < 0) err_sys("shutdown error"); if ( (n = read_stream(sockfd, reply, REPLY)) < 0) err_sys("read error"); /* process "n" bytes of reply[] ... */ exit(0); }