Changeset ebb1489 in mainline for uspace/srv/hid/remcons/remcons.c

Timestamp:

2024-10-13T08:23:40Z (2 months ago)

Author:

GitHub <noreply@…>

Children:

0472cf17

Parents:

2a0c827c (diff), b3b79981 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

boba-buba <120932204+boba-buba@…> (2024-10-13 08:23:40)

git-committer:

GitHub <noreply@…> (2024-10-13 08:23:40)

Message:

Merge branch 'HelenOS:master' into topic/packet-capture

File:

• uspace/srv/hid/remcons/remcons.c (modified) (22 diffs)

uspace/srv/hid/remcons/remcons.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2023 Jiri Svoboda
+ * Copyright (c) 2024 Jiri Svoboda
  * Copyright (c) 2012 Vojtech Horky
  * All rights reserved.
@@ -34 +34 @@
  */
 
+#include <adt/list.h>
+#include <as.h>
 #include <async.h>
 #include <errno.h>
@@ -51 +53 @@
 #include <inttypes.h>
 #include <str.h>
+#include <vt/vt100.h>
 #include "telnet.h"
 #include "user.h"
+#include "remcons.h"
 
 #define APP_GETTERM  "/app/getterm"
 #define APP_SHELL "/app/bdsh"
+
+#define DEF_PORT 2223
 
 /** Telnet commands to force character mode
@@ -74 +80 @@
 static errno_t remcons_open(con_srvs_t *, con_srv_t *);
 static errno_t remcons_close(con_srv_t *);
+static errno_t remcons_read(con_srv_t *, void *, size_t, size_t *);
 static errno_t remcons_write(con_srv_t *, void *, size_t, size_t *);
 static void remcons_sync(con_srv_t *);
@@ -81 +88 @@
 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 void remcons_set_style(con_srv_t *, console_style_t);
+static void remcons_set_color(con_srv_t *, console_color_t,
+    console_color_t, console_color_attr_t);
+static void remcons_set_color(con_srv_t *, console_color_t,
+    console_color_t, console_color_attr_t);
+static void remcons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
+static void remcons_cursor_visibility(con_srv_t *, bool);
 static errno_t remcons_get_event(con_srv_t *, cons_event_t *);
+static errno_t remcons_map(con_srv_t *, sysarg_t, sysarg_t, charfield_t **);
+static void remcons_unmap(con_srv_t *);
+static void remcons_update(con_srv_t *, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t);
 
 static con_ops_t con_ops = {
         .open = remcons_open,
         .close = remcons_close,
-        .read = NULL,
+        .read = remcons_read,
         .write = remcons_write,
         .sync = remcons_sync,
@@ -94 +112 @@
         .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
+        .set_style = remcons_set_style,
+        .set_color = remcons_set_color,
+        .set_rgb_color = remcons_set_rgb_color,
+        .set_cursor_visibility = remcons_cursor_visibility,
+        .get_event = remcons_get_event,
+        .map = remcons_map,
+        .unmap = remcons_unmap,
+        .update = remcons_update
+};
+
+static void remcons_vt_putchar(void *, char32_t);
+static void remcons_vt_cputs(void *, const char *);
+static void remcons_vt_flush(void *);
+static void remcons_vt_key(void *, keymod_t, keycode_t, char);
+static void remcons_vt_pos_event(void *, pos_event_t *);
+
+static vt100_cb_t remcons_vt_cb = {
+        .putuchar = remcons_vt_putchar,
+        .control_puts = remcons_vt_cputs,
+        .flush = remcons_vt_flush,
+        .key = remcons_vt_key,
+        .pos_event = remcons_vt_pos_event
 };
 
@@ -111 +146 @@
 };
 
+static void remcons_telnet_ws_update(void *, unsigned, unsigned);
+
+static telnet_cb_t remcons_telnet_cb = {
+        .ws_update = remcons_telnet_ws_update
+};
+
 static loc_srv_t *remcons_srv;
+static bool no_ctl;
+static bool no_rgb;
 
 static telnet_user_t *srv_to_user(con_srv_t *srv)
 {
-        return srv->srvs->sarg;
+        remcons_t *remcons = (remcons_t *)srv->srvs->sarg;
+        return remcons->user;
+}
+
+static remcons_t *srv_to_remcons(con_srv_t *srv)
+{
+        remcons_t *remcons = (remcons_t *)srv->srvs->sarg;
+        return remcons;
 }
 
@@ -141 +191 @@
 }
 
-static errno_t remcons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
+static errno_t remcons_read(con_srv_t *srv, void *data, size_t size,
+    size_t *nread)
 {
         telnet_user_t *user = srv_to_user(srv);
         errno_t rc;
 
-        rc = telnet_user_send_data(user, data, size);
+        rc = telnet_user_recv(user, data, size, nread);
         if (rc != EOK)
                 return rc;
 
+        return EOK;
+}
+
+static errno_t remcons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        errno_t rc;
+
+        rc = telnet_user_send_data(remcons->user, data, size);
+        if (rc != EOK)
+                return rc;
+
+        rc = telnet_user_flush(remcons->user);
+        if (rc != EOK)
+                return rc;
+
         *nwritten = size;
         return EOK;
@@ -161 +228 @@
 static void remcons_clear(con_srv_t *srv)
 {
-        (void) srv;
+        remcons_t *remcons = srv_to_remcons(srv);
+
+        if (remcons->enable_ctl) {
+                vt100_cls(remcons->vt);
+                vt100_set_pos(remcons->vt, 0, 0);
+                remcons->user->cursor_x = 0;
+                remcons->user->cursor_y = 0;
+        }
 }
 
 static void remcons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
 {
+        remcons_t *remcons = srv_to_remcons(srv);
         telnet_user_t *user = srv_to_user(srv);
 
-        telnet_user_update_cursor_x(user, col);
+        if (remcons->enable_ctl) {
+                vt100_set_pos(remcons->vt, col, row);
+                remcons->user->cursor_x = col;
+                remcons->user->cursor_y = row;
+                (void)telnet_user_flush(remcons->user);
+        } else {
+                telnet_user_update_cursor_x(user, col);
+        }
 }
 
@@ -176 +258 @@
 
         *col = user->cursor_x;
-        *row = 0;
+        *row = user->cursor_y;
 
         return EOK;
@@ -183 +265 @@
 static errno_t remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
 {
-        (void) srv;
-
-        *cols = 100;
-        *rows = 1;
+        remcons_t *remcons = srv_to_remcons(srv);
+
+        if (remcons->enable_ctl) {
+                *cols = remcons->vt->cols;
+                *rows = remcons->vt->rows;
+        } else {
+                *cols = 100;
+                *rows = 1;
+        }
 
         return EOK;
@@ -193 +280 @@
 static errno_t remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
 {
-        (void) srv;
-        *ccaps = CONSOLE_CAP_NONE;
+        remcons_t *remcons = srv_to_remcons(srv);
+
+        *ccaps = 0;
+
+        if (remcons->enable_ctl) {
+                *ccaps |= CONSOLE_CAP_CURSORCTL | CONSOLE_CAP_STYLE |
+                    CONSOLE_CAP_INDEXED;
+        }
+
+        if (remcons->enable_rgb)
+                *ccaps |= CONSOLE_CAP_RGB;
 
         return EOK;
 }
 
+static void remcons_set_style(con_srv_t *srv, console_style_t style)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        char_attrs_t attrs;
+
+        if (remcons->enable_ctl) {
+                attrs.type = CHAR_ATTR_STYLE;
+                attrs.val.style = style;
+                vt100_set_attr(remcons->vt, attrs);
+        }
+}
+
+static void remcons_set_color(con_srv_t *srv, console_color_t bgcolor,
+    console_color_t fgcolor, console_color_attr_t flags)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        char_attrs_t attrs;
+
+        if (remcons->enable_ctl) {
+                attrs.type = CHAR_ATTR_INDEX;
+                attrs.val.index.bgcolor = bgcolor;
+                attrs.val.index.fgcolor = fgcolor;
+                attrs.val.index.attr = flags;
+                vt100_set_attr(remcons->vt, attrs);
+        }
+}
+
+static void remcons_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
+    pixel_t fgcolor)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        char_attrs_t attrs;
+
+        if (remcons->enable_ctl) {
+                attrs.type = CHAR_ATTR_RGB;
+                attrs.val.rgb.bgcolor = bgcolor;
+                attrs.val.rgb.fgcolor = fgcolor;
+                vt100_set_attr(remcons->vt, attrs);
+        }
+}
+
+static void remcons_cursor_visibility(con_srv_t *srv, bool visible)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+
+        if (remcons->enable_ctl) {
+                if (!remcons->curs_visible && visible) {
+                        vt100_set_pos(remcons->vt, remcons->user->cursor_x,
+                            remcons->user->cursor_y);
+                }
+                vt100_cursor_visibility(remcons->vt, visible);
+        }
+
+        remcons->curs_visible = visible;
+}
+
+/** Creates new keyboard event from given char.
+ *
+ * @param type Event type (press / release).
+ * @param c Pressed character.
+ */
+static remcons_event_t *new_kbd_event(kbd_event_type_t type, keymod_t mods,
+    keycode_t key, char c)
+{
+        remcons_event_t *event = malloc(sizeof(remcons_event_t));
+        if (event == NULL) {
+                fprintf(stderr, "Out of memory.\n");
+                return NULL;
+        }
+
+        link_initialize(&event->link);
+        event->cev.type = CEV_KEY;
+        event->cev.ev.key.type = type;
+        event->cev.ev.key.mods = mods;
+        event->cev.ev.key.key = key;
+        event->cev.ev.key.c = c;
+
+        return event;
+}
+
+/** Creates new position event.
+ *
+ * @param ev Position event.
+ * @param c Pressed character.
+ */
+static remcons_event_t *new_pos_event(pos_event_t *ev)
+{
+        remcons_event_t *event = malloc(sizeof(remcons_event_t));
+        if (event == NULL) {
+                fprintf(stderr, "Out of memory.\n");
+                return NULL;
+        }
+
+        link_initialize(&event->link);
+        event->cev.type = CEV_POS;
+        event->cev.ev.pos = *ev;
+
+        return event;
+}
+
+/** Creates new console resize event.
+ */
+static remcons_event_t *new_resize_event(void)
+{
+        remcons_event_t *event = malloc(sizeof(remcons_event_t));
+        if (event == NULL) {
+                fprintf(stderr, "Out of memory.\n");
+                return NULL;
+        }
+
+        link_initialize(&event->link);
+        event->cev.type = CEV_RESIZE;
+
+        return event;
+}
+
 static errno_t remcons_get_event(con_srv_t *srv, cons_event_t *event)
 {
+        remcons_t *remcons = srv_to_remcons(srv);
         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) {
-                /* XXX What? */
-                memset(event, 0, sizeof(*event));
-                return EOK;
-        }
-
-        event->type = CEV_KEY;
-        event->ev.key = kevent;
+        size_t nread;
+
+        while (list_empty(&remcons->in_events)) {
+                char next_byte = 0;
+
+                errno_t rc = telnet_user_recv(user, &next_byte, 1,
+                    &nread);
+                if (rc != EOK)
+                        return rc;
+
+                vt100_rcvd_char(remcons->vt, next_byte);
+        }
+
+        link_t *link = list_first(&remcons->in_events);
+        list_remove(link);
+
+        remcons_event_t *tmp = list_get_instance(link, remcons_event_t, link);
+
+        *event = tmp->cev;
+        free(tmp);
 
         return EOK;
+}
+
+static errno_t remcons_map(con_srv_t *srv, sysarg_t cols, sysarg_t rows,
+    charfield_t **rbuf)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        void *buf;
+
+        if (!remcons->enable_ctl)
+                return ENOTSUP;
+
+        if (remcons->ubuf != NULL)
+                return EBUSY;
+
+        buf = as_area_create(AS_AREA_ANY, cols * rows * sizeof(charfield_t),
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
+        if (buf == AS_MAP_FAILED)
+                return ENOMEM;
+
+        remcons->ucols = cols;
+        remcons->urows = rows;
+        remcons->ubuf = buf;
+
+        *rbuf = buf;
+        return EOK;
+
+}
+
+static void remcons_unmap(con_srv_t *srv)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        void *buf;
+
+        buf = remcons->ubuf;
+        remcons->ubuf = NULL;
+
+        if (buf != NULL)
+                as_area_destroy(buf);
+}
+
+static void remcons_update(con_srv_t *srv, sysarg_t c0, sysarg_t r0,
+    sysarg_t c1, sysarg_t r1)
+{
+        remcons_t *remcons = srv_to_remcons(srv);
+        charfield_t *ch;
+        sysarg_t col, row;
+        sysarg_t old_x, old_y;
+
+        if (remcons->ubuf == NULL)
+                return;
+
+        /* Make sure we have meaningful coordinates, within bounds */
+
+        if (c1 > remcons->ucols)
+                c1 = remcons->ucols;
+        if (c1 > remcons->user->cols)
+                c1 = remcons->user->cols;
+        if (c0 >= c1)
+                return;
+
+        if (r1 > remcons->urows)
+                r1 = remcons->urows;
+        if (r1 > remcons->user->rows)
+                r1 = remcons->user->rows;
+        if (r0 >= r1)
+                return;
+
+        /* Update screen from user buffer */
+
+        old_x = remcons->user->cursor_x;
+        old_y = remcons->user->cursor_y;
+
+        if (remcons->curs_visible)
+                vt100_cursor_visibility(remcons->vt, false);
+
+        for (row = r0; row < r1; row++) {
+                for (col = c0; col < c1; col++) {
+                        vt100_set_pos(remcons->vt, col, row);
+                        ch = &remcons->ubuf[row * remcons->ucols + col];
+                        vt100_set_attr(remcons->vt, ch->attrs);
+                        vt100_putuchar(remcons->vt, ch->ch);
+                }
+        }
+
+        if (remcons->curs_visible) {
+                old_x = remcons->user->cursor_x = old_x;
+                remcons->user->cursor_y = old_y;
+                vt100_set_pos(remcons->vt, old_x, old_y);
+                vt100_cursor_visibility(remcons->vt, true);
+        }
+
+        /* Flush data */
+        (void)telnet_user_flush(remcons->user);
 }
 
@@ -248 +562 @@
                     "failed: %s.", APP_GETTERM, user->service_name, APP_SHELL,
                     str_error(rc));
-                fibril_mutex_lock(&user->guard);
+                fibril_mutex_lock(&user->recv_lock);
                 user->task_finished = true;
                 user->srvs.aborted = true;
                 fibril_condvar_signal(&user->refcount_cv);
-                fibril_mutex_unlock(&user->guard);
+                fibril_mutex_unlock(&user->recv_lock);
                 return EOK;
         }
 
-        fibril_mutex_lock(&user->guard);
+        fibril_mutex_lock(&user->recv_lock);
         user->task_id = task;
-        fibril_mutex_unlock(&user->guard);
+        fibril_mutex_unlock(&user->recv_lock);
 
         task_exit_t task_exit;
@@ -268 +582 @@
 
         /* Announce destruction. */
-        fibril_mutex_lock(&user->guard);
+        fibril_mutex_lock(&user->recv_lock);
         user->task_finished = true;
         user->srvs.aborted = true;
         fibril_condvar_signal(&user->refcount_cv);
-        fibril_mutex_unlock(&user->guard);
+        fibril_mutex_unlock(&user->recv_lock);
 
         return EOK;
@@ -285 +599 @@
         return user->task_finished && user->socket_closed &&
             (user->locsrv_connection_count == 0);
+}
+
+static void remcons_vt_putchar(void *arg, char32_t c)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+        char buf[STR_BOUNDS(1)];
+        size_t off;
+        errno_t rc;
+
+        (void)arg;
+
+        off = 0;
+        rc = chr_encode(c, buf, &off, sizeof(buf));
+        if (rc != EOK)
+                return;
+
+        (void)telnet_user_send_data(remcons->user, buf, off);
+}
+
+static void remcons_vt_cputs(void *arg, const char *str)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+
+        (void)telnet_user_send_raw(remcons->user, str, str_size(str));
+}
+
+static void remcons_vt_flush(void *arg)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+        (void)telnet_user_flush(remcons->user);
+}
+
+static void remcons_vt_key(void *arg, keymod_t mods, keycode_t key, char c)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+
+        remcons_event_t *down = new_kbd_event(KEY_PRESS, mods, key, c);
+        if (down == NULL)
+                return;
+
+        remcons_event_t *up = new_kbd_event(KEY_RELEASE, mods, key, c);
+        if (up == NULL) {
+                free(down);
+                return;
+        }
+
+        list_append(&down->link, &remcons->in_events);
+        list_append(&up->link, &remcons->in_events);
+}
+
+static void remcons_vt_pos_event(void *arg, pos_event_t *ev)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+
+        remcons_event_t *cev = new_pos_event(ev);
+        if (cev == NULL)
+                return;
+
+        list_append(&cev->link, &remcons->in_events);
+}
+
+/** Window size update callback.
+ *
+ * @param arg Argument (remcons_t *)
+ * @param cols New number of columns
+ * @param rows New number of rows
+ */
+static void remcons_telnet_ws_update(void *arg, unsigned cols, unsigned rows)
+{
+        remcons_t *remcons = (remcons_t *)arg;
+
+        vt100_resize(remcons->vt, cols, rows);
+        telnet_user_resize(remcons->user, cols, rows);
+
+        remcons_event_t *resize = new_resize_event();
+        if (resize == NULL)
+                return;
+
+        list_append(&resize->link, &remcons->in_events);
 }
 
@@ -294 +687 @@
 static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
 {
-        telnet_user_t *user = telnet_user_create(conn);
-        assert(user);
+        char_attrs_t attrs;
+        remcons_t *remcons = NULL;
+        telnet_user_t *user = NULL;
+
+        remcons = calloc(1, sizeof(remcons_t));
+        if (remcons == NULL) {
+                fprintf(stderr, "Out of memory.\n");
+                goto error;
+        }
+
+        user = telnet_user_create(conn, &remcons_telnet_cb,
+            (void *)remcons);
+        if (user == NULL) {
+                fprintf(stderr, "Out of memory.\n");
+                goto error;
+        }
+
+        remcons->enable_ctl = !no_ctl;
+        remcons->enable_rgb = !no_ctl && !no_rgb;
+        remcons->user = user;
+        list_initialize(&remcons->in_events);
+
+        if (remcons->enable_ctl) {
+                user->cols = 80;
+                user->rows = 25;
+        } else {
+                user->cols = 100;
+                user->rows = 1;
+        }
+
+        remcons->curs_visible = true;
+
+        remcons->vt = vt100_create((void *)remcons, 80, 25, &remcons_vt_cb);
+        if (remcons->vt == NULL) {
+                fprintf(stderr, "Error creating VT100 driver instance.\n");
+                goto error;
+        }
+
+        remcons->vt->enable_rgb = remcons->enable_rgb;
+
+        if (remcons->enable_ctl) {
+                attrs.type = CHAR_ATTR_STYLE;
+                attrs.val.style = STYLE_NORMAL;
+                vt100_set_sgr(remcons->vt, attrs);
+                vt100_cls(remcons->vt);
+                vt100_set_pos(remcons->vt, 0, 0);
+                vt100_set_button_reporting(remcons->vt, true);
+        }
 
         con_srvs_init(&user->srvs);
         user->srvs.ops = &con_ops;
-        user->srvs.sarg = user;
-        user->srvs.abort_timeout = 1000;
+        user->srvs.sarg = remcons;
+        user->srvs.abort_timeout = 1000000;
 
         telnet_user_add(user);
@@ -309 +748 @@
                 telnet_user_error(user, "Unable to register %s with loc: %s.",
                     user->service_name, str_error(rc));
-                return;
+                goto error;
         }
 
@@ -316 +755 @@
 
         fid_t spawn_fibril = fibril_create(spawn_task_fibril, user);
-        assert(spawn_fibril);
+        if (spawn_fibril == 0) {
+                fprintf(stderr, "Failed creating fibril.\n");
+                goto error;
+        }
         fibril_add_ready(spawn_fibril);
 
         /* Wait for all clients to exit. */
-        fibril_mutex_lock(&user->guard);
+        fibril_mutex_lock(&user->recv_lock);
         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) {
@@ -332 +772 @@
                         }
                 }
-                fibril_condvar_wait_timeout(&user->refcount_cv, &user->guard, 1000);
-        }
-        fibril_mutex_unlock(&user->guard);
+                fibril_condvar_wait_timeout(&user->refcount_cv,
+                    &user->recv_lock, 1000000);
+        }
+        fibril_mutex_unlock(&user->recv_lock);
 
         rc = loc_service_unregister(remcons_srv, user->service_id);
@@ -344 +785 @@
 
         telnet_user_log(user, "Destroying...");
+
+        if (remcons->enable_ctl) {
+                /* Disable mouse tracking */
+                vt100_set_button_reporting(remcons->vt, false);
+
+                /* Reset all character attributes and clear screen */
+                vt100_sgr(remcons->vt, 0);
+                vt100_cls(remcons->vt);
+                vt100_set_pos(remcons->vt, 0, 0);
+
+                telnet_user_flush(user);
+        }
+
+        tcp_conn_send_fin(user->conn);
+        user->conn = NULL;
+
         telnet_user_destroy(user);
+        vt100_destroy(remcons->vt);
+        free(remcons);
+        return;
+error:
+        if (user != NULL && user->service_id != 0)
+                loc_service_unregister(remcons_srv, user->service_id);
+        if (user != NULL)
+                free(user);
+        if (remcons != NULL && remcons->vt != NULL)
+                vt100_destroy(remcons->vt);
+        if (remcons != NULL)
+                free(remcons);
+}
+
+static void print_syntax(void)
+{
+        fprintf(stderr, "syntax: remcons [<options>]\n");
+        fprintf(stderr, "\t--no-ctl      Disable all terminal control sequences\n");
+        fprintf(stderr, "\t--no-rgb      Disable RGB colors\n");
+        fprintf(stderr, "\t--port <port> Listening port (default: %u)\n",
+            DEF_PORT);
 }
 
@@ -353 +831 @@
         tcp_t *tcp;
         inet_ep_t ep;
+        uint16_t port;
+        int i;
+
+        port = DEF_PORT;
+
+        i = 1;
+        while (i < argc) {
+                if (argv[i][0] == '-') {
+                        if (str_cmp(argv[i], "--no-ctl") == 0) {
+                                no_ctl = true;
+                        } else if (str_cmp(argv[i], "--no-rgb") == 0) {
+                                no_rgb = true;
+                        } else if (str_cmp(argv[i], "--port") == 0) {
+                                ++i;
+                                if (i >= argc) {
+                                        fprintf(stderr, "Option argument "
+                                            "missing.\n");
+                                        print_syntax();
+                                        return EINVAL;
+                                }
+                                rc = str_uint16_t(argv[i], NULL, 10, true, &port);
+                                if (rc != EOK) {
+                                        fprintf(stderr, "Invalid port number "
+                                            "'%s'.\n", argv[i]);
+                                        print_syntax();
+                                        return EINVAL;
+                                }
+                        } else {
+                                fprintf(stderr, "Unknown option '%s'.\n",
+                                    argv[i]);
+                                print_syntax();
+                                return EINVAL;
+                        }
+                } else {
+                        fprintf(stderr, "Unexpected argument.\n");
+                        print_syntax();
+                        return EINVAL;
+                }
+
+                ++i;
+        }
 
         async_set_fallback_port_handler(client_connection, NULL);
@@ -368 +887 @@
 
         inet_ep_init(&ep);
-        ep.port = 2223;
+        ep.port = port;
 
         rc = tcp_listener_create(tcp, &ep, &listen_cb, NULL, &conn_cb, NULL,