Changeset 178d6a3 in mainline

Timestamp:

2012-01-12T11:03:17Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

03e0a244

Parents:

c17c4e28

Message:

remcons: handle backspace

The handling is a bit hackish because the server pretends that it remembers
X cursor position and sends BS manually when they differ (with the new one)
by minus one.

Location:

uspace/srv/hid/remcons

Files:

• remcons.c (modified) (3 diffs)
• user.c (modified) (4 diffs)
• user.h (modified) (2 diffs)

uspace/srv/hid/remcons/remcons.c

@@ -112 +112 @@
                         break;
                 case CONSOLE_GET_POS:
-                        async_answer_2(callid, EOK, 0, 0);
+                        fibril_mutex_lock(&user->guard);
+                        async_answer_2(callid, EOK, user->cursor_x, 0);
+                        fibril_mutex_unlock(&user->guard);
                         break;
                 case CONSOLE_GET_EVENT: {
@@ -125 +127 @@
                         break;
                 }
-                case CONSOLE_GOTO:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
+                case CONSOLE_GOTO: {
+                        int new_x = IPC_GET_ARG1(call);
+                        telnet_user_update_cursor_x(user, new_x);
+                        async_answer_0(callid, ENOTSUP);
+                        break;
+                }
                 case VFS_OUT_READ:
                         async_answer_0(callid, ENOTSUP);
                         break;
                 case VFS_OUT_WRITE: {
-                        char *buf;
-                        char *buf_converted;
+                        uint8_t *buf;
                         size_t size;
                         int rc = async_data_write_accept((void **)&buf, false, 0, 0, 0, &size);
@@ -141 +145 @@
                                 break;
                         }
-                        buf_converted = malloc(2 * size + 1);
-                        assert(buf_converted);
-                        int buf_converted_size = 0;
-                        /* Convert new-lines. */
-                        for (size_t i = 0; i < size; i++) {
-                                if (buf[i] == 10) {
-                                        buf_converted[buf_converted_size++] = 13;
-                                        buf_converted[buf_converted_size++] = 10;
-                                } else {
-                                        buf_converted[buf_converted_size++] = buf[i];
-                                }
-                        }
-                        /* Add terminating zero for printing purposes. */
-                        buf_converted[buf_converted_size] = 0;
-
-                        fibril_mutex_lock(&user->guard);
-                        rc = send(user->socket, buf_converted, buf_converted_size, 0);
-                        fibril_mutex_unlock(&user->guard);
+
+                        rc = telnet_user_send_data(user, buf, size);
                         free(buf);
 

uspace/srv/hid/remcons/user.c

@@ -100 +100 @@
         fibril_mutex_unlock(&users_guard);
 
+        user->cursor_x = 0;
+
         return user;
 }
@@ -245 +247 @@
 }
 
+/** Process telnet command (currently only print to screen).
+ *
+ * @param user Telnet user structure.
+ * @param option_code Command option code.
+ * @param cmd Telnet command.
+ */
 static void process_telnet_command(telnet_user_t *user,
     telnet_cmd_t option_code, telnet_cmd_t cmd)
@@ -257 +265 @@
 }
 
+/** Get next keyboard event.
+ *
+ * @param user Telnet user.
+ * @param event Where to store the keyboard event.
+ * @return Error code.
+ */
 int telnet_user_get_next_keyboard_event(telnet_user_t *user, kbd_event_t *event)
 {
@@ -318 +332 @@
 }
 
+/** Send data (convert them first) to the socket, no locking.
+ *
+ * @param user Telnet user.
+ * @param data Data buffer (not zero terminated).
+ * @param size Size of @p data buffer in bytes.
+ */
+static int telnet_user_send_data_no_lock(telnet_user_t *user, uint8_t *data, size_t size)
+{
+        uint8_t *converted = malloc(3 * size + 1);
+        assert(converted);
+        int converted_size = 0;
+
+        /* Convert new-lines. */
+        for (size_t i = 0; i < size; i++) {
+                if (data[i] == 10) {
+                        converted[converted_size++] = 13;
+                        converted[converted_size++] = 10;
+                        user->cursor_x = 0;
+                } else {
+                        converted[converted_size++] = data[i];
+                        if (data[i] == '\b') {
+                                user->cursor_x--;
+                        } else {
+                                user->cursor_x++;
+                        }
+                }
+        }
+
+
+        int rc = send(user->socket, converted, converted_size, 0);
+        free(converted);
+
+        return rc;
+}
+
+/** Send data (convert them first) to the socket.
+ *
+ * @param user Telnet user.
+ * @param data Data buffer (not zero terminated).
+ * @param size Size of @p data buffer in bytes.
+ */
+int telnet_user_send_data(telnet_user_t *user, uint8_t *data, size_t size)
+{
+        fibril_mutex_lock(&user->guard);
+
+        int rc = telnet_user_send_data_no_lock(user, data, size);
+
+        fibril_mutex_unlock(&user->guard);
+
+        return rc;
+}
+
+/** Update cursor X position.
+ *
+ * This call may result in sending control commands over socket.
+ *
+ * @param user Telnet user.
+ * @param new_x New cursor location.
+ */
+void telnet_user_update_cursor_x(telnet_user_t *user, int new_x)
+{
+        fibril_mutex_lock(&user->guard);
+        if (user->cursor_x - 1 == new_x) {
+                uint8_t data = '\b';
+                /* Ignore errors. */
+                telnet_user_send_data_no_lock(user, &data, 1);
+        }
+        user->cursor_x = new_x;
+        fibril_mutex_unlock(&user->guard);
+
+}
+
 /**
  * @}

uspace/srv/hid/remcons/user.h

@@ -71 +71 @@
         int locsrv_connection_count;
         bool socket_closed;
+
+        /** X position of the cursor. */
+        int cursor_x;
 } telnet_user_t;
 
@@ -79 +82 @@
 void telnet_user_notify_client_disconnected(telnet_user_t *user);
 int telnet_user_get_next_keyboard_event(telnet_user_t *user, kbd_event_t *event);
+int telnet_user_send_data(telnet_user_t *user, uint8_t *data, size_t size);
+void telnet_user_update_cursor_x(telnet_user_t *user, int new_x);
 
 /** Print informational message about connected user. */