HelenOS sources
This source file includes following definitions.
- srv_to_user
- remcons_open
- remcons_close
- remcons_write
- remcons_sync
- remcons_clear
- remcons_set_pos
- remcons_get_pos
- remcons_get_size
- remcons_get_color_cap
- remcons_get_event
- client_connection
- spawn_task_fibril
- user_can_be_destroyed_no_lock
- remcons_new_conn
- main
#include <async.h>
#include <errno.h>
#include <io/con_srv.h>
#include <stdio.h>
#include <stdlib.h>
#include <str_error.h>
#include <loc.h>
#include <io/keycode.h>
#include <align.h>
#include <fibril_synch.h>
#include <task.h>
#include <inet/addr.h>
#include <inet/endpoint.h>
#include <inet/tcp.h>
#include <io/console.h>
#include <inttypes.h>
#include <str.h>
#include "telnet.h"
#include "user.h"
#define APP_GETTERM "/app/getterm"
#define APP_SHELL "/app/bdsh"
static const telnet_cmd_t telnet_force_character_mode_command[] = {
TELNET_IAC, TELNET_WILL, TELNET_ECHO,
TELNET_IAC, TELNET_WILL, TELNET_SUPPRESS_GO_AHEAD,
TELNET_IAC, TELNET_WONT, TELNET_LINEMODE
};
static const size_t telnet_force_character_mode_command_count =
sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
static errno_t remcons_open(con_srvs_t *, con_srv_t *);
static errno_t remcons_close(con_srv_t *);
static errno_t remcons_write(con_srv_t *, void *, size_t, size_t *);
static void remcons_sync(con_srv_t *);
static void remcons_clear(con_srv_t *);
static void remcons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
static errno_t remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
static errno_t remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
static errno_t remcons_get_color_cap(con_srv_t *, console_caps_t *);
static errno_t remcons_get_event(con_srv_t *, cons_event_t *);
static con_ops_t con_ops = {
.open = remcons_open,
.close = remcons_close,
.read = NULL,
.write = remcons_write,
.sync = remcons_sync,
.clear = remcons_clear,
.set_pos = remcons_set_pos,
.get_pos = remcons_get_pos,
.get_size = remcons_get_size,
.get_color_cap = remcons_get_color_cap,
.set_style = NULL,
.set_color = NULL,
.set_rgb_color = NULL,
.set_cursor_visibility = NULL,
.get_event = remcons_get_event
};
static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn);
static tcp_listen_cb_t listen_cb = {
.new_conn = remcons_new_conn
};
static tcp_cb_t conn_cb = {
.connected = NULL
};
static loc_srv_t *remcons_srv;
static telnet_user_t *srv_to_user(con_srv_t *srv)
{
return srv->srvs->sarg;
}
static errno_t remcons_open(con_srvs_t *srvs, con_srv_t *srv)
{
telnet_user_t *user = srv_to_user(srv);
telnet_user_log(user, "New client connected (%p).", srv);
(void) tcp_conn_send(user->conn, (void *)telnet_force_character_mode_command,
telnet_force_character_mode_command_count);
return EOK;
}
static errno_t remcons_close(con_srv_t *srv)
{
telnet_user_t *user = srv_to_user(srv);
telnet_user_notify_client_disconnected(user);
telnet_user_log(user, "Client disconnected (%p).", srv);
return EOK;
}
static errno_t remcons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
{
telnet_user_t *user = srv_to_user(srv);
errno_t rc;
rc = telnet_user_send_data(user, data, size);
if (rc != EOK)
return rc;
*nwritten = size;
return EOK;
}
static void remcons_sync(con_srv_t *srv)
{
(void) srv;
}
static void remcons_clear(con_srv_t *srv)
{
(void) srv;
}
static void remcons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
{
telnet_user_t *user = srv_to_user(srv);
telnet_user_update_cursor_x(user, col);
}
static errno_t remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
{
telnet_user_t *user = srv_to_user(srv);
*col = user->cursor_x;
*row = 0;
return EOK;
}
static errno_t remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
{
(void) srv;
*cols = 100;
*rows = 1;
return EOK;
}
static errno_t remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
{
(void) srv;
*ccaps = CONSOLE_CAP_NONE;
return EOK;
}
static errno_t remcons_get_event(con_srv_t *srv, cons_event_t *event)
{
telnet_user_t *user = srv_to_user(srv);
kbd_event_t kevent;
errno_t rc;
rc = telnet_user_get_next_keyboard_event(user, &kevent);
if (rc != EOK) {
memset(event, 0, sizeof(*event));
return EOK;
}
event->type = CEV_KEY;
event->ev.key = kevent;
return EOK;
}
static void client_connection(ipc_call_t *icall, void *arg)
{
telnet_user_t *user = telnet_user_get_for_client_connection(ipc_get_arg2(icall));
if (user == NULL) {
async_answer_0(icall, ENOENT);
return;
}
con_conn(icall, &user->srvs);
}
static errno_t spawn_task_fibril(void *arg)
{
telnet_user_t *user = arg;
task_id_t task;
task_wait_t wait;
errno_t rc = task_spawnl(&task, &wait, APP_GETTERM, APP_GETTERM, user->service_name,
"/loc", "--msg", "--", APP_SHELL, NULL);
if (rc != EOK) {
telnet_user_error(user, "Spawning `%s %s /loc --msg -- %s' "
"failed: %s.", APP_GETTERM, user->service_name, APP_SHELL,
str_error(rc));
fibril_mutex_lock(&user->guard);
user->task_finished = true;
user->srvs.aborted = true;
fibril_condvar_signal(&user->refcount_cv);
fibril_mutex_unlock(&user->guard);
return EOK;
}
fibril_mutex_lock(&user->guard);
user->task_id = task;
fibril_mutex_unlock(&user->guard);
task_exit_t task_exit;
int task_retval;
task_wait(&wait, &task_exit, &task_retval);
telnet_user_log(user, "%s terminated %s, exit code %d.", APP_GETTERM,
task_exit == TASK_EXIT_NORMAL ? "normally" : "unexpectedly",
task_retval);
fibril_mutex_lock(&user->guard);
user->task_finished = true;
user->srvs.aborted = true;
fibril_condvar_signal(&user->refcount_cv);
fibril_mutex_unlock(&user->guard);
return EOK;
}
static bool user_can_be_destroyed_no_lock(telnet_user_t *user)
{
return user->task_finished && user->socket_closed &&
(user->locsrv_connection_count == 0);
}
static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
{
telnet_user_t *user = telnet_user_create(conn);
assert(user);
con_srvs_init(&user->srvs);
user->srvs.ops = &con_ops;
user->srvs.sarg = user;
user->srvs.abort_timeout = 1000;
telnet_user_add(user);
errno_t rc = loc_service_register(remcons_srv, user->service_name,
&user->service_id);
if (rc != EOK) {
telnet_user_error(user, "Unable to register %s with loc: %s.",
user->service_name, str_error(rc));
return;
}
telnet_user_log(user, "Service %s registerd with id %" PRIun ".",
user->service_name, user->service_id);
fid_t spawn_fibril = fibril_create(spawn_task_fibril, user);
assert(spawn_fibril);
fibril_add_ready(spawn_fibril);
fibril_mutex_lock(&user->guard);
while (!user_can_be_destroyed_no_lock(user)) {
if (user->task_finished) {
user->conn = NULL;
user->socket_closed = true;
user->srvs.aborted = true;
continue;
} else if (user->socket_closed) {
if (user->task_id != 0) {
task_kill(user->task_id);
}
}
fibril_condvar_wait_timeout(&user->refcount_cv, &user->guard, 1000);
}
fibril_mutex_unlock(&user->guard);
rc = loc_service_unregister(remcons_srv, user->service_id);
if (rc != EOK) {
telnet_user_error(user,
"Unable to unregister %s from loc: %s (ignored).",
user->service_name, str_error(rc));
}
telnet_user_log(user, "Destroying...");
telnet_user_destroy(user);
}
int main(int argc, char *argv[])
{
errno_t rc;
tcp_listener_t *lst;
tcp_t *tcp;
inet_ep_t ep;
async_set_fallback_port_handler(client_connection, NULL);
rc = loc_server_register(NAME, &remcons_srv);
if (rc != EOK) {
fprintf(stderr, "%s: Unable to register server\n", NAME);
return rc;
}
rc = tcp_create(&tcp);
if (rc != EOK) {
fprintf(stderr, "%s: Error initializing TCP.\n", NAME);
return rc;
}
inet_ep_init(&ep);
ep.port = 2223;
rc = tcp_listener_create(tcp, &ep, &listen_cb, NULL, &conn_cb, NULL,
&lst);
if (rc != EOK) {
fprintf(stderr, "%s: Error creating listener.\n", NAME);
return rc;
}
printf("%s: HelenOS Remote console service\n", NAME);
task_retval(0);
async_manager();
return 0;
}
HelenOS homepage, sources at GitHub