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 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_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 read_memory_fill_array_cb(InputStream * inp, void * args) {
MemoryFillBuffer * buf = (MemoryFillBuffer *)args;
if (buf->pos >= buf->max) {
buf->buf = (char *)tmp_realloc(buf->buf, buf->max *= 2);
}
buf->buf[buf->pos++] = (char)json_read_ulong(inp);
}
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 read_location_element(InputStream * inp, void * args) {
Location * loc = (Location *)args;
switch (loc_pos) {
case 0:
json_read_string(inp, loc->id, sizeof(loc->id));
break;
case 1:
loc->offs = json_read_ulong(inp);
break;
case 2:
loc->size = json_read_ulong(inp);
break;
default:
json_skip_object(inp);
break;
}
loc_pos++;
}
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 PortServer * create_server(Channel * c, PortAttribute * attrs) {
int sock = -1;
struct sockaddr_in addr;
PortAttribute * attr = attrs;
#if defined(_WRS_KERNEL)
int addrlen;
#else
socklen_t addrlen;
#endif
u_short port_number;
PortServer * server = NULL;
int is_udp = 0; /* do we use a server UDP -or TCP- port? */
char * port_config = NULL;
int error = 0;
int auto_connect = 0;
uint64_t auto_connect_period = 0;
unsigned int local_port = 0;
while (attr != NULL) {
if (strcmp(attr->name, "Port") == 0) {
ByteArrayInputStream buf;
InputStream * inp = create_byte_array_input_stream(&buf, attr->value, strlen(attr->value));
port_config = json_read_alloc_string(inp);
if (strncasecmp(port_config, "udp:", strlen("udp:")) == 0) {
is_udp = 1;
}
}
else if (strcmp(attr->name, "AutoConnect") == 0) {
ByteArrayInputStream buf;
InputStream * inp = create_byte_array_input_stream(&buf, attr->value, strlen(attr->value));
auto_connect = json_read_boolean(inp);
}
else if (strcmp(attr->name, "AutoConnectPeriod") == 0) {
ByteArrayInputStream buf;
InputStream * inp = create_byte_array_input_stream(&buf, attr->value, strlen(attr->value));
auto_connect_period = json_read_ulong(inp);
}
else if (strcmp(attr->name, "LocalPort") == 0) {
ByteArrayInputStream buf;
InputStream * inp = create_byte_array_input_stream(&buf, attr->value, strlen(attr->value));
local_port = (unsigned int) json_read_uint64(inp);
}
attr = attr->next;
}
if (port_config == NULL) {
error = set_errno(ERR_OTHER, "No port configuration is specified");
}
if (error == 0) {
loc_free(port_config);
memset((void *) &addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = (u_short) htons(local_port);
if (is_udp) sock = socket(AF_INET, SOCK_DGRAM, 0);
else if ((sock = socket(AF_INET, SOCK_STREAM, 0)) >= 0) set_socket_options(sock); /* set socket options */
if (sock == -1) error = errno;
}
if (error == 0) {
if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
error = errno;
}
}
if (error == 0 && !is_udp) {
if (listen(sock, 16) != 0) error = errno;
}
if (error == 0) {
/* Get port property in case the default port could not be used or
* the client specified a port that the system converts to a
* dynamic port number. */
addrlen = sizeof addr;
if (getsockname(sock, (struct sockaddr *) &addr, &addrlen) < 0) error = errno;
}
if (error == 0) {
port_number = (u_short) ntohs(addr.sin_port);
server = (PortServer *)loc_alloc_zero(sizeof(PortServer));
server->sock = sock;
server->is_udp = is_udp;
#if defined(SOCK_MAXADDRLEN)
server->addr_len = SOCK_MAXADDRLEN;
#else
server->addr_len = 0x1000;
#endif
server->addr_buf = (struct sockaddr *)loc_alloc(server->addr_len);
server->local_port = port_number;
if (!server->is_udp) {
server->accept_in_progress = 1;
server->auto_connect = auto_connect;
server->accreq.done = port_server_accept_done;
server->accreq.client_data = server;
server->accreq.type = AsyncReqAccept;
server->accreq.u.acc.sock = sock;
server->accreq.u.acc.addr = server->addr_buf;
server->accreq.u.acc.addrlen = server->addr_len;
async_req_post(&server->accreq);
}
else
{
/* For UDP, automatically connect to the port since there is no
* connection request we can detect.
*/
server->auto_connect = 1;
}
server->auto_connect_period = auto_connect_period;
list_add_last(&server->link, &server_list);
channel_lock_with_msg(server->channel = c, channel_lock_svr_msg);
snprintf (server->id, sizeof(server->id), "PS%" PRIu64, port_server_id++);
server->attrs = attrs;
}
if (error == 0) return server;
else {
if (sock != -1) closesocket(sock);
loc_free(server);
return NULL ;
}
}