source: mainline/uspace/srv/hid/remcons/remcons.c@ 5c65e61

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5c65e61 was 902f0906, checked in by Jiri Svoboda <jiri@…>, 12 years ago

Multiple event type support in console IPC stubs.
  • Property mode set to 100644
File size: 10.1 KB
Line 
1/*
2 * Copyright (c) 2012 Vojtech Horky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup remcons
30 * @{
31 */
32/** @file
33 */
34
35#include <async.h>
36#include <errno.h>
37#include <io/con_srv.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <str_error.h>
41#include <loc.h>
42#include <event.h>
43#include <io/keycode.h>
44#include <align.h>
45#include <fibril_synch.h>
46#include <task.h>
47#include <net/in.h>
48#include <net/inet.h>
49#include <net/socket.h>
50#include <io/console.h>
51#include <inttypes.h>
52#include "telnet.h"
53#include "user.h"
54
55#define APP_GETTERM "/app/getterm"
56#define APP_SHELL "/app/bdsh"
57
58/** Telnet commands to force character mode
59 * (redundant to be on the safe side).
60 * See
61 * http://stackoverflow.com/questions/273261/force-telnet-user-into-character-mode
62 * for discussion.
63 */
64static const telnet_cmd_t telnet_force_character_mode_command[] = {
65 TELNET_IAC, TELNET_WILL, TELNET_ECHO,
66 TELNET_IAC, TELNET_WILL, TELNET_SUPPRESS_GO_AHEAD,
67 TELNET_IAC, TELNET_WONT, TELNET_LINEMODE
68};
69
70static const size_t telnet_force_character_mode_command_count =
71 sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
72
73static int remcons_open(con_srvs_t *, con_srv_t *);
74static int remcons_close(con_srv_t *);
75static int remcons_write(con_srv_t *, void *, size_t);
76static void remcons_sync(con_srv_t *);
77static void remcons_clear(con_srv_t *);
78static void remcons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
79static int remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
80static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
81static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
82static int remcons_get_event(con_srv_t *, cons_event_t *);
83
84static con_ops_t con_ops = {
85 .open = remcons_open,
86 .close = remcons_close,
87 .read = NULL,
88 .write = remcons_write,
89 .sync = remcons_sync,
90 .clear = remcons_clear,
91 .set_pos = remcons_set_pos,
92 .get_pos = remcons_get_pos,
93 .get_size = remcons_get_size,
94 .get_color_cap = remcons_get_color_cap,
95 .set_style = NULL,
96 .set_color = NULL,
97 .set_rgb_color = NULL,
98 .set_cursor_visibility = NULL,
99 .get_event = remcons_get_event
100};
101
102static telnet_user_t *srv_to_user(con_srv_t *srv)
103{
104 return srv->srvs->sarg;
105}
106
107static int remcons_open(con_srvs_t *srvs, con_srv_t *srv)
108{
109 telnet_user_t *user = srv_to_user(srv);
110
111 telnet_user_log(user, "New client connected (%p).", srv);
112
113 /* Force character mode. */
114 send(user->socket, (void *)telnet_force_character_mode_command,
115 telnet_force_character_mode_command_count, 0);
116
117 return EOK;
118}
119
120static int remcons_close(con_srv_t *srv)
121{
122 telnet_user_t *user = srv_to_user(srv);
123
124 telnet_user_notify_client_disconnected(user);
125 telnet_user_log(user, "Client disconnected (%p).", srv);
126
127 return EOK;
128}
129
130static int remcons_write(con_srv_t *srv, void *data, size_t size)
131{
132 telnet_user_t *user = srv_to_user(srv);
133 int rc;
134
135 rc = telnet_user_send_data(user, data, size);
136 if (rc != EOK)
137 return rc;
138
139 return size;
140}
141
142static void remcons_sync(con_srv_t *srv)
143{
144 (void) srv;
145}
146
147static void remcons_clear(con_srv_t *srv)
148{
149 (void) srv;
150}
151
152static void remcons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
153{
154 telnet_user_t *user = srv_to_user(srv);
155
156 telnet_user_update_cursor_x(user, col);
157}
158
159static int remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
160{
161 telnet_user_t *user = srv_to_user(srv);
162
163 *col = user->cursor_x;
164 *row = 0;
165
166 return EOK;
167}
168
169static int remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
170{
171 (void) srv;
172
173 *cols = 100;
174 *rows = 1;
175
176 return EOK;
177}
178
179static int remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
180{
181 (void) srv;
182 *ccaps = CONSOLE_CAP_NONE;
183
184 return EOK;
185}
186
187static int remcons_get_event(con_srv_t *srv, cons_event_t *event)
188{
189 telnet_user_t *user = srv_to_user(srv);
190 kbd_event_t kevent;
191 int rc;
192
193 rc = telnet_user_get_next_keyboard_event(user, &kevent);
194 if (rc != EOK) {
195 /* XXX What? */
196 memset(event, 0, sizeof(*event));
197 return EOK;
198 }
199
200 event->type = CEV_KEY;
201 event->ev.key = kevent;
202
203 return EOK;
204}
205
206/** Callback when client connects to a telnet terminal. */
207static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
208{
209 /* Find the user. */
210 telnet_user_t *user = telnet_user_get_for_client_connection(IPC_GET_ARG1(*icall));
211 if (user == NULL) {
212 async_answer_0(iid, ENOENT);
213 return;
214 }
215
216 /* Handle messages. */
217 con_conn(iid, icall, &user->srvs);
218}
219
220/** Fibril for spawning the task running after user connects.
221 *
222 * @param arg Corresponding @c telnet_user_t structure.
223 */
224static int spawn_task_fibril(void *arg)
225{
226 telnet_user_t *user = arg;
227 int rc;
228
229 char term[LOC_NAME_MAXLEN];
230 snprintf(term, LOC_NAME_MAXLEN, "%s/%s", "/loc", user->service_name);
231
232 task_id_t task;
233 rc = task_spawnl(&task, APP_GETTERM, APP_GETTERM, "-w", term, APP_SHELL, NULL);
234 if (rc != EOK) {
235 telnet_user_error(user, "Spawning `%s -w %s %s' failed: %s.",
236 APP_GETTERM, term, APP_SHELL, str_error(rc));
237 fibril_mutex_lock(&user->guard);
238 user->task_finished = true;
239 user->srvs.aborted = true;
240 fibril_condvar_signal(&user->refcount_cv);
241 fibril_mutex_unlock(&user->guard);
242 return EOK;
243 }
244
245 fibril_mutex_lock(&user->guard);
246 user->task_id = task;
247 fibril_mutex_unlock(&user->guard);
248
249 task_exit_t task_exit;
250 int task_retval;
251 task_wait(task, &task_exit, &task_retval);
252 telnet_user_log(user, "%s terminated %s, exit code %d.", APP_GETTERM,
253 task_exit == TASK_EXIT_NORMAL ? "normally" : "unexpectedly",
254 task_retval);
255
256 /* Announce destruction. */
257 fibril_mutex_lock(&user->guard);
258 user->task_finished = true;
259 user->srvs.aborted = true;
260 fibril_condvar_signal(&user->refcount_cv);
261 fibril_mutex_unlock(&user->guard);
262
263 return EOK;
264}
265
266/** Tell whether given user can be destroyed (has no active clients).
267 *
268 * @param user The telnet user in question.
269 */
270static bool user_can_be_destroyed_no_lock(telnet_user_t *user)
271{
272 return user->task_finished && user->socket_closed &&
273 (user->locsrv_connection_count == 0);
274}
275
276/** Fibril for each accepted socket.
277 *
278 * @param arg Corresponding @c telnet_user_t structure.
279 */
280static int network_user_fibril(void *arg)
281{
282 telnet_user_t *user = arg;
283
284 int rc = loc_service_register(user->service_name, &user->service_id);
285 if (rc != EOK) {
286 telnet_user_error(user, "Unable to register %s with loc: %s.",
287 user->service_name, str_error(rc));
288 return EOK;
289 }
290
291 telnet_user_log(user, "Service %s registerd with id %" PRIun ".",
292 user->service_name, user->service_id);
293
294 fid_t spawn_fibril = fibril_create(spawn_task_fibril, user);
295 assert(spawn_fibril);
296 fibril_add_ready(spawn_fibril);
297
298 /* Wait for all clients to exit. */
299 fibril_mutex_lock(&user->guard);
300 while (!user_can_be_destroyed_no_lock(user)) {
301 if (user->task_finished) {
302 closesocket(user->socket);
303 user->socket_closed = true;
304 user->srvs.aborted = true;
305 continue;
306 } else if (user->socket_closed) {
307 if (user->task_id != 0) {
308 task_kill(user->task_id);
309 }
310 }
311 fibril_condvar_wait_timeout(&user->refcount_cv, &user->guard, 1000);
312 }
313 fibril_mutex_unlock(&user->guard);
314
315 rc = loc_service_unregister(user->service_id);
316 if (rc != EOK) {
317 telnet_user_error(user,
318 "Unable to unregister %s from loc: %s (ignored).",
319 user->service_name, str_error(rc));
320 }
321
322 telnet_user_log(user, "Destroying...");
323 telnet_user_destroy(user);
324
325 return EOK;
326}
327
328int main(int argc, char *argv[])
329{
330 int port = 2223;
331
332 async_set_client_connection(client_connection);
333 int rc = loc_server_register(NAME);
334 if (rc != EOK) {
335 fprintf(stderr, "%s: Unable to register server\n", NAME);
336 return rc;
337 }
338
339 struct sockaddr_in addr;
340
341 addr.sin_family = AF_INET;
342 addr.sin_port = htons(port);
343
344 rc = inet_pton(AF_INET, "127.0.0.1", (void *)
345 &addr.sin_addr.s_addr);
346 if (rc != EOK) {
347 fprintf(stderr, "Error parsing network address: %s.\n",
348 str_error(rc));
349 return 2;
350 }
351
352 int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
353 if (listen_sd < 0) {
354 fprintf(stderr, "Error creating listening socket: %s.\n",
355 str_error(listen_sd));
356 return 3;
357 }
358
359 rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
360 if (rc != EOK) {
361 fprintf(stderr, "Error binding socket: %s.\n",
362 str_error(rc));
363 return 4;
364 }
365
366 rc = listen(listen_sd, BACKLOG_SIZE);
367 if (rc != EOK) {
368 fprintf(stderr, "listen() failed: %s.\n", str_error(rc));
369 return 5;
370 }
371
372 printf("%s: HelenOS Remote console service\n", NAME);
373 task_retval(0);
374
375 while (true) {
376 struct sockaddr_in raddr;
377 socklen_t raddr_len = sizeof(raddr);
378 int conn_sd = accept(listen_sd, (struct sockaddr *) &raddr,
379 &raddr_len);
380
381 if (conn_sd < 0) {
382 fprintf(stderr, "accept() failed: %s.\n",
383 str_error(rc));
384 continue;
385 }
386
387 telnet_user_t *user = telnet_user_create(conn_sd);
388 assert(user);
389
390 con_srvs_init(&user->srvs);
391 user->srvs.ops = &con_ops;
392 user->srvs.sarg = user;
393 user->srvs.abort_timeout = 1000;
394
395 telnet_user_add(user);
396
397 fid_t fid = fibril_create(network_user_fibril, user);
398 assert(fid);
399 fibril_add_ready(fid);
400 }
401
402 return 0;
403}
404
405/** @}
406 */
Note: See TracBrowser for help on using the repository browser.