Use guac_error appropriately.
[libguac-client-rdp.git] / src / guac_handlers.c
index b95ad7f..ef4c0cb 100644 (file)
 #include <freerdp/freerdp.h>
 #include <freerdp/channels/channels.h>
 #include <freerdp/input.h>
+#include <freerdp/codec/color.h>
+#include <freerdp/cache/cache.h>
 
 #include <guacamole/socket.h>
 #include <guacamole/protocol.h>
 #include <guacamole/client.h>
+#include <guacamole/error.h>
 
 #include "client.h"
 #include "rdp_keymap.h"
 #include "guac_handlers.h"
 
+void __guac_rdp_update_keysyms(guac_client* client, const int* keysym_string, int from, int to);
+int __guac_rdp_send_keysym(guac_client* client, int keysym, int pressed);
+void __guac_rdp_send_altcode(guac_client* client, int altcode);
+
+
 int rdp_guac_client_free_handler(guac_client* client) {
 
-    /* STUB */
+    rdp_guac_client_data* guac_client_data =
+        (rdp_guac_client_data*) client->data;
+
+    freerdp* rdp_inst = guac_client_data->rdp_inst;
+    rdpChannels* channels = rdp_inst->context->channels;
 
-    /* FIXME: Clean up RDP client + disconnect */
+    /* Clean up RDP client */
+       freerdp_channels_close(channels, rdp_inst);
+       freerdp_channels_free(channels);
+       freerdp_disconnect(rdp_inst);
+    freerdp_clrconv_free(((rdp_freerdp_context*) rdp_inst->context)->clrconv);
+    cache_free(rdp_inst->context->cache);
+    freerdp_free(rdp_inst);
+
+    /* Free client data */
+    free(guac_client_data);
 
     return 0;
 
@@ -85,13 +106,15 @@ int rdp_guac_client_handle_messages(guac_client* client) {
 
     /* get rdp fds */
     if (!freerdp_get_fds(rdp_inst, read_fds, &read_count, write_fds, &write_count)) {
-        guac_client_log_error(client, "Unable to read RDP file descriptors.");
+        guac_error = GUAC_STATUS_BAD_STATE;
+        guac_error_message = "Unable to read RDP file descriptors";
         return 1;
     }
 
     /* get channel fds */
     if (!freerdp_channels_get_fds(channels, rdp_inst, read_fds, &read_count, write_fds, &write_count)) {
-        guac_client_log_error(client, "Unable to read RDP channel file descriptors.");
+        guac_error = GUAC_STATUS_BAD_STATE;
+        guac_error_message = "Unable to read RDP channel file descriptors";
         return 1;
     }
 
@@ -116,7 +139,8 @@ int rdp_guac_client_handle_messages(guac_client* client) {
 
     /* If no file descriptors, error */
     if (max_fd == 0) {
-        guac_client_log_error(client, "No file descriptors");
+        guac_error = GUAC_STATUS_BAD_STATE;
+        guac_error_message = "No file descriptors";
         return 1;
     }
 
@@ -128,20 +152,23 @@ int rdp_guac_client_handle_messages(guac_client* client) {
             (errno == EINPROGRESS) ||
             (errno == EINTR))) /* signal occurred */
         {
-            guac_client_log_error(client, "Error waiting for file descriptor.");
+            guac_error = GUAC_STATUS_SEE_ERRNO;
+            guac_error_message = "Error waiting for file descriptor";
             return 1;
         }
     }
 
     /* Check the libfreerdp fds */
     if (!freerdp_check_fds(rdp_inst)) {
-        guac_client_log_error(client, "Error handling RDP file descriptors.");
+        guac_error = GUAC_STATUS_BAD_STATE;
+        guac_error_message = "Error handling RDP file descriptors";
         return 1;
     }
 
     /* Check channel fds */
     if (!freerdp_channels_check_fds(channels, rdp_inst)) {
-        guac_client_log_error(client, "Error handling RDP channel file descriptors.");
+        guac_error = GUAC_STATUS_BAD_STATE;
+        guac_error_message = "Error handling RDP channel file descriptors";
         return 1;
     }
 
@@ -223,80 +250,139 @@ int rdp_guac_client_mouse_handler(guac_client* client, int x, int y, int mask) {
     return 0;
 }
 
-void __guac_rdp_send_altcode(guac_client* client, const char* altcode) {
+void __guac_rdp_send_altcode(guac_client* client, int altcode) {
 
     rdp_guac_client_data* guac_client_data = (rdp_guac_client_data*) client->data;
     freerdp* rdp_inst = guac_client_data->rdp_inst;
-    const guac_rdp_keysym_scancode_map* keysym_scancodes = guac_client_data->keysym_scancodes;
+    int i;
 
     /* Lookup scancode for Alt */
-    int alt = GUAC_RDP_KEYSYM_LOOKUP(*keysym_scancodes, 0xFFE9 /* Alt_L */)->scancode;
-    guac_client_log_info(client, "ALTCODE: alt=%i", alt);
+    int alt = GUAC_RDP_KEYSYM_LOOKUP(
+            guac_client_data->keymap,
+            0xFFE9 /* Alt_L */).scancode;
+
+    /* Release all pressed modifiers */
+    __guac_rdp_update_keysyms(client, GUAC_KEYSYMS_ALL_MODIFIERS, 1, 0);
 
     /* Press Alt */
     rdp_inst->input->KeyboardEvent(rdp_inst->input, KBD_FLAGS_DOWN, alt);
 
-    /* For each character in Alt-code ... */
-    while (*altcode != '\0') {
+    /* For each character in four-digit Alt-code ... */
+    for (i=0; i<4; i++) {
 
         /* Get scancode of keypad digit */
-        int scancode = GUAC_RDP_KEYSYM_LOOKUP(*keysym_scancodes, 0xFFB0 + (*altcode) - '0')->scancode;
+        int scancode = GUAC_RDP_KEYSYM_LOOKUP(
+                guac_client_data->keymap,
+                0xFFB0 + (altcode / 1000)
+        ).scancode;
 
         /* Press and release digit */
         rdp_inst->input->KeyboardEvent(rdp_inst->input, KBD_FLAGS_DOWN, scancode);
         rdp_inst->input->KeyboardEvent(rdp_inst->input, KBD_FLAGS_RELEASE, scancode);
-        guac_client_log_info(client, "ALTCODE: scan=%i", scancode);
 
-        /* Next character */
-        altcode++;
+        /* Shift digits left by one place */
+        altcode = (altcode * 10) % 10000;
+
     }
 
     /* Release Alt */
     rdp_inst->input->KeyboardEvent(rdp_inst->input, KBD_FLAGS_RELEASE, alt);
-    guac_client_log_info(client, "ALTCODE: done");
+
+    /* Press all originally pressed modifiers */
+    __guac_rdp_update_keysyms(client, GUAC_KEYSYMS_ALL_MODIFIERS, 1, 1);
 
 }
 
-int rdp_guac_client_key_handler(guac_client* client, int keysym, int pressed) {
+int __guac_rdp_send_keysym(guac_client* client, int keysym, int pressed) {
 
     rdp_guac_client_data* guac_client_data = (rdp_guac_client_data*) client->data;
     freerdp* rdp_inst = guac_client_data->rdp_inst;
-    const guac_rdp_keysym_scancode_map* keysym_scancodes = guac_client_data->keysym_scancodes;
 
     /* If keysym can be in lookup table */
     if (keysym <= 0xFFFF) {
 
         /* Look up scancode mapping */
-        const guac_rdp_scancode_map* scancode_map = GUAC_RDP_KEYSYM_LOOKUP(*keysym_scancodes, keysym);
+        const guac_rdp_keysym_desc* keysym_desc =
+            &GUAC_RDP_KEYSYM_LOOKUP(guac_client_data->keymap, keysym);
 
         /* If defined, send event */
-        if (scancode_map->scancode != 0)
+        if (keysym_desc->scancode != 0) {
+
+            /* If defined, send any prerequesite keys that must be set */
+            if (keysym_desc->set_keysyms != NULL)
+                __guac_rdp_update_keysyms(client, keysym_desc->set_keysyms, 0, 1);
+
+            /* If defined, release any keys that must be cleared */
+            if (keysym_desc->clear_keysyms != NULL)
+                __guac_rdp_update_keysyms(client, keysym_desc->clear_keysyms, 1, 0);
+
+            /* Send actual key */
             rdp_inst->input->KeyboardEvent(
                     rdp_inst->input,
-                    scancode_map->flags
+                    keysym_desc->flags
                         | (pressed ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE),
-                    scancode_map->scancode);
+                    keysym_desc->scancode);
 
-        /* If undefined, try to type using Alt-code */
-        else {
+            /* If defined, release any keys that were originally released */
+            if (keysym_desc->set_keysyms != NULL)
+                __guac_rdp_update_keysyms(client, keysym_desc->set_keysyms, 0, 0);
 
-            const guac_rdp_altcode_map* altcode_map = GUAC_RDP_KEYSYM_LOOKUP(guac_rdp_keysym_altcode, keysym);
-            if (altcode_map->altcode != NULL) {
+            /* If defined, send any keys that were originally set */
+            if (keysym_desc->clear_keysyms != NULL)
+                __guac_rdp_update_keysyms(client, keysym_desc->clear_keysyms, 1, 1);
 
-                /* Only send Alt-code on press */
-                if (pressed)
-                    __guac_rdp_send_altcode(client, altcode_map->altcode);
+        }
 
-            }
+        /* If undefined but has Alt-code, use Alt-Code */
+        else if (keysym <= 0xFF) {
 
-            /* If no defined Alt-code, log warning */
-            else
-                guac_client_log_info(client, "unmapped keysym: 0x%x", keysym);
+            /* NOTE: The Alt-codes are conveniently identical to keysyms. */
+
+            /* Only send Alt-code on press */
+            if (pressed)
+                __guac_rdp_send_altcode(client, keysym);
 
         }
 
+        /* If no defined Alt-code, log warning */
+        else
+            guac_client_log_info(client, "unmapped keysym: 0x%x", keysym);
+
     }
 
     return 0;
 }
 
+void __guac_rdp_update_keysyms(guac_client* client, const int* keysym_string, int from, int to) {
+
+    rdp_guac_client_data* guac_client_data = (rdp_guac_client_data*) client->data;
+    int keysym;
+
+    /* Send all keysyms in string, NULL terminated */
+    while ((keysym = *keysym_string) != 0) {
+
+        /* Get current keysym state */
+        int current_state = GUAC_RDP_KEYSYM_LOOKUP(guac_client_data->keysym_state, keysym);
+
+        /* If key is currently in given state, send event for changing it to specified "to" state */
+        if (current_state == from)
+            __guac_rdp_send_keysym(client, *keysym_string, to);
+
+        /* Next keysym */
+        keysym_string++;
+
+    }
+
+}
+
+int rdp_guac_client_key_handler(guac_client* client, int keysym, int pressed) {
+
+    rdp_guac_client_data* guac_client_data = (rdp_guac_client_data*) client->data;
+
+    /* Update keysym state */
+    GUAC_RDP_KEYSYM_LOOKUP(guac_client_data->keysym_state, keysym) = pressed;
+
+    return __guac_rdp_send_keysym(client, keysym, pressed);
+
+}
+