diff options
Diffstat (limited to 'backend/rdp')
| -rw-r--r-- | backend/rdp/backend.c | 134 | ||||
| -rw-r--r-- | backend/rdp/keyboard.c | 219 | ||||
| -rw-r--r-- | backend/rdp/listener.c | 61 | ||||
| -rw-r--r-- | backend/rdp/output.c | 288 | ||||
| -rw-r--r-- | backend/rdp/peer.c | 360 | ||||
| -rw-r--r-- | backend/rdp/pointer.c | 40 |
6 files changed, 1102 insertions, 0 deletions
diff --git a/backend/rdp/backend.c b/backend/rdp/backend.c new file mode 100644 index 00000000..ef0fca85 --- /dev/null +++ b/backend/rdp/backend.c @@ -0,0 +1,134 @@ +#define _POSIX_C_SOURCE 200809L +#include <assert.h> +#include <stdlib.h> +#include <string.h> +#include <wlr/render/egl.h> +#include <wlr/render/gles2.h> +#include <wlr/util/log.h> +#include "backend/rdp.h" +#include "glapi.h" +#include "util/signal.h" + +struct wlr_rdp_backend *rdp_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_rdp(wlr_backend)); + return (struct wlr_rdp_backend *)wlr_backend; +} + +static bool backend_start(struct wlr_backend *wlr_backend) { + struct wlr_rdp_backend *backend = + rdp_backend_from_backend(wlr_backend); + assert(backend->listener == NULL); + wlr_log(WLR_INFO, "Starting RDP backend"); + if (!rdp_configure_listener(backend)) { + return false; + } + return true; +} + +void wlr_rdp_backend_set_address(struct wlr_backend *wlr_backend, + const char *address) { + struct wlr_rdp_backend *backend = + rdp_backend_from_backend(wlr_backend); + assert(backend->listener == NULL); + backend->address = strdup(address); +} + +void wlr_rdp_backend_set_port(struct wlr_backend *wlr_backend, int port) { + struct wlr_rdp_backend *backend = + rdp_backend_from_backend(wlr_backend); + assert(backend->listener == NULL); + backend->port = port; +} + +static void backend_destroy(struct wlr_backend *wlr_backend) { + struct wlr_rdp_backend *backend = + rdp_backend_from_backend(wlr_backend); + if (!wlr_backend) { + return; + } + + wl_list_remove(&backend->display_destroy.link); + + struct wlr_rdp_peer_context *client; + wl_list_for_each(client, &backend->clients, link) { + freerdp_peer_context_free(client->peer); + freerdp_peer_free(client->peer); + } + + wlr_signal_emit_safe(&wlr_backend->events.destroy, backend); + + wlr_renderer_destroy(backend->renderer); + wlr_egl_finish(&backend->egl); + free(backend->address); + free(backend); +} + +static struct wlr_renderer *backend_get_renderer( + struct wlr_backend *wlr_backend) { + struct wlr_rdp_backend *backend = + rdp_backend_from_backend(wlr_backend); + return backend->renderer; +} + +static const struct wlr_backend_impl backend_impl = { + .start = backend_start, + .destroy = backend_destroy, + .get_renderer = backend_get_renderer, +}; + +static void handle_display_destroy(struct wl_listener *listener, void *data) { + struct wlr_rdp_backend *backend = + wl_container_of(listener, backend, display_destroy); + backend_destroy(&backend->backend); +} + +struct wlr_backend *wlr_rdp_backend_create(struct wl_display *display, + wlr_renderer_create_func_t create_renderer_func, + const char *tls_cert_path, const char *tls_key_path) { + wlr_log(WLR_INFO, "Creating RDP backend"); + + struct wlr_rdp_backend *backend = + calloc(1, sizeof(struct wlr_rdp_backend)); + if (!backend) { + wlr_log(WLR_ERROR, "Failed to allocate wlr_rdp_backend"); + return NULL; + } + wlr_backend_init(&backend->backend, &backend_impl); + backend->display = display; + backend->tls_cert_path = tls_cert_path; + backend->tls_key_path = tls_key_path; + backend->address = strdup("127.0.0.1"); + backend->port = 3389; + wl_list_init(&backend->clients); + + static const EGLint config_attribs[] = { + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_ALPHA_SIZE, 0, + EGL_BLUE_SIZE, 1, + EGL_GREEN_SIZE, 1, + EGL_RED_SIZE, 1, + EGL_NONE, + }; + + if (!create_renderer_func) { + create_renderer_func = wlr_renderer_autocreate; + } + + backend->renderer = create_renderer_func(&backend->egl, + EGL_PLATFORM_SURFACELESS_MESA, NULL, (EGLint*)config_attribs, 0); + if (!backend->renderer) { + wlr_log(WLR_ERROR, "Failed to create renderer"); + free(backend); + return NULL; + } + + backend->display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &backend->display_destroy); + + return &backend->backend; +} + +bool wlr_backend_is_rdp(struct wlr_backend *backend) { + return backend->impl == &backend_impl; +} diff --git a/backend/rdp/keyboard.c b/backend/rdp/keyboard.c new file mode 100644 index 00000000..b3c5869d --- /dev/null +++ b/backend/rdp/keyboard.c @@ -0,0 +1,219 @@ +#include <stdlib.h> +#include <wayland-server.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_keyboard.h> +#include <wlr/interfaces/wlr_keyboard.h> +#include <wlr/interfaces/wlr_input_device.h> +#include <wlr/util/log.h> +#include <xkbcommon/xkbcommon.h> +#include "backend/rdp.h" +#include "util/signal.h" + +struct rdp_to_xkb_keyboard_layout { + UINT32 rdp_layout_code; + const char *xkb_layout; + const char *xkb_variant; +}; + +/* table reversed from + https://github.com/awakecoding/FreeRDP/blob/master/libfreerdp/locale/xkb_layout_ids.c#L811 */ +static struct rdp_to_xkb_keyboard_layout rdp_keyboards[] = { + {KBD_ARABIC_101, "ara", 0}, + {KBD_BULGARIAN, 0, 0}, + {KBD_CHINESE_TRADITIONAL_US, 0, 0}, + {KBD_CZECH, "cz", 0}, + {KBD_CZECH_PROGRAMMERS, "cz", "bksl"}, + {KBD_CZECH_QWERTY, "cz", "qwerty"}, + {KBD_DANISH, "dk", 0}, + {KBD_GERMAN, "de", 0}, + {KBD_GERMAN_NEO, "de", "neo"}, + {KBD_GERMAN_IBM, "de", "qwerty"}, + {KBD_GREEK, "gr", 0}, + {KBD_GREEK_220, "gr", "simple"}, + {KBD_GREEK_319, "gr", "extended"}, + {KBD_GREEK_POLYTONIC, "gr", "polytonic"}, + {KBD_US, "us", 0}, + {KBD_US_ENGLISH_TABLE_FOR_IBM_ARABIC_238_L, "ara", "buckwalter"}, + {KBD_SPANISH, "es", 0}, + {KBD_SPANISH_VARIATION, "es", "nodeadkeys"}, + {KBD_FINNISH, "fi", 0}, + {KBD_FRENCH, "fr", 0}, + {KBD_HEBREW, "il", 0}, + {KBD_HUNGARIAN, "hu", 0}, + {KBD_HUNGARIAN_101_KEY, "hu", "standard"}, + {KBD_ICELANDIC, "is", 0}, + {KBD_ITALIAN, "it", 0}, + {KBD_ITALIAN_142, "it", "nodeadkeys"}, + {KBD_JAPANESE, "jp", 0}, + {KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002, "jp", "kana"}, + {KBD_KOREAN, "kr", 0}, + {KBD_KOREAN_INPUT_SYSTEM_IME_2000, "kr", "kr104"}, + {KBD_DUTCH, "nl", 0}, + {KBD_NORWEGIAN, "no", 0}, + {KBD_POLISH_PROGRAMMERS, "pl", 0}, + {KBD_POLISH_214, "pl", "qwertz"}, + {KBD_ROMANIAN, "ro", 0}, + {KBD_RUSSIAN, "ru", 0}, + {KBD_RUSSIAN_TYPEWRITER, "ru", "typewriter"}, + {KBD_CROATIAN, "hr", 0}, + {KBD_SLOVAK, "sk", 0}, + {KBD_SLOVAK_QWERTY, "sk", "qwerty"}, + {KBD_ALBANIAN, 0, 0}, + {KBD_SWEDISH, "se", 0}, + {KBD_THAI_KEDMANEE, "th", 0}, + {KBD_THAI_KEDMANEE_NON_SHIFTLOCK, "th", "tis"}, + {KBD_TURKISH_Q, "tr", 0}, + {KBD_TURKISH_F, "tr", "f"}, + {KBD_URDU, "in", "urd-phonetic3"}, + {KBD_UKRAINIAN, "ua", 0}, + {KBD_BELARUSIAN, "by", 0}, + {KBD_SLOVENIAN, "si", 0}, + {KBD_ESTONIAN, "ee", 0}, + {KBD_LATVIAN, "lv", 0}, + {KBD_LITHUANIAN_IBM, "lt", "ibm"}, + {KBD_FARSI, "af", 0}, + {KBD_VIETNAMESE, "vn", 0}, + {KBD_ARMENIAN_EASTERN, "am", 0}, + {KBD_AZERI_LATIN, 0, 0}, + {KBD_FYRO_MACEDONIAN, "mk", 0}, + {KBD_GEORGIAN, "ge", 0}, + {KBD_FAEROESE, 0, 0}, + {KBD_DEVANAGARI_INSCRIPT, 0, 0}, + {KBD_MALTESE_47_KEY, 0, 0}, + {KBD_NORWEGIAN_WITH_SAMI, "no", "smi"}, + {KBD_KAZAKH, "kz", 0}, + {KBD_KYRGYZ_CYRILLIC, "kg", "phonetic"}, + {KBD_TATAR, "ru", "tt"}, + {KBD_BENGALI, "bd", 0}, + {KBD_BENGALI_INSCRIPT, "bd", "probhat"}, + {KBD_PUNJABI, 0, 0}, + {KBD_GUJARATI, "in", "guj"}, + {KBD_TAMIL, "in", "tam"}, + {KBD_TELUGU, "in", "tel"}, + {KBD_KANNADA, "in", "kan"}, + {KBD_MALAYALAM, "in", "mal"}, + {KBD_HINDI_TRADITIONAL, "in", 0}, + {KBD_MARATHI, 0, 0}, + {KBD_MONGOLIAN_CYRILLIC, "mn", 0}, + {KBD_UNITED_KINGDOM_EXTENDED, "gb", "intl"}, + {KBD_SYRIAC, "syc", 0}, + {KBD_SYRIAC_PHONETIC, "syc", "syc_phonetic"}, + {KBD_NEPALI, "np", 0}, + {KBD_PASHTO, "af", "ps"}, + {KBD_DIVEHI_PHONETIC, 0, 0}, + {KBD_LUXEMBOURGISH, 0, 0}, + {KBD_MAORI, "mao", 0}, + {KBD_CHINESE_SIMPLIFIED_US, 0, 0}, + {KBD_SWISS_GERMAN, "ch", "de_nodeadkeys"}, + {KBD_UNITED_KINGDOM, "gb", 0}, + {KBD_LATIN_AMERICAN, "latam", 0}, + {KBD_BELGIAN_FRENCH, "be", 0}, + {KBD_BELGIAN_PERIOD, "be", "oss_sundeadkeys"}, + {KBD_PORTUGUESE, "pt", 0}, + {KBD_SERBIAN_LATIN, "rs", 0}, + {KBD_AZERI_CYRILLIC, "az", "cyrillic"}, + {KBD_SWEDISH_WITH_SAMI, "se", "smi"}, + {KBD_UZBEK_CYRILLIC, "af", "uz"}, + {KBD_INUKTITUT_LATIN, "ca", "ike"}, + {KBD_CANADIAN_FRENCH_LEGACY, "ca", "fr-legacy"}, + {KBD_SERBIAN_CYRILLIC, "rs", 0}, + {KBD_CANADIAN_FRENCH, "ca", "fr-legacy"}, + {KBD_SWISS_FRENCH, "ch", "fr"}, + {KBD_BOSNIAN, "ba", 0}, + {KBD_IRISH, 0, 0}, + {KBD_BOSNIAN_CYRILLIC, "ba", "us"}, + {KBD_UNITED_STATES_DVORAK, "us", "dvorak"}, + {KBD_PORTUGUESE_BRAZILIAN_ABNT2, "br", "nativo"}, + {KBD_CANADIAN_MULTILINGUAL_STANDARD, "ca", "multix"}, + {KBD_GAELIC, "ie", "CloGaelach"}, + + {0x00000000, 0, 0}, +}; + +/* taken from 2.2.7.1.6 Input Capability Set (TS_INPUT_CAPABILITYSET) */ +static char *rdp_keyboard_types[] = { + "", /* 0: unused */ + "", /* 1: IBM PC/XT or compatible (83-key) keyboard */ + "", /* 2: Olivetti "ICO" (102-key) keyboard */ + "", /* 3: IBM PC/AT (84-key) or similar keyboard */ + "pc102",/* 4: IBM enhanced (101- or 102-key) keyboard */ + "", /* 5: Nokia 1050 and similar keyboards */ + "", /* 6: Nokia 9140 and similar keyboards */ + "" /* 7: Japanese keyboard */ +}; + +static void keyboard_destroy(struct wlr_input_device *wlr_device) { + struct wlr_rdp_keyboard *keyboard = + (struct wlr_rdp_keyboard *)wlr_device->keyboard; + xkb_keymap_unref(keyboard->keymap); + free(keyboard); +} + +static struct wlr_input_device_impl input_device_impl = { + .destroy = keyboard_destroy, +}; + +struct wlr_rdp_input_device *wlr_rdp_keyboard_create( + struct wlr_rdp_backend *backend, rdpSettings *settings) { + struct wlr_rdp_input_device *device = + calloc(1, sizeof(struct wlr_rdp_input_device)); + if (!device) { + wlr_log(WLR_ERROR, "Failed to allcoate RDP input device"); + return NULL; + } + + int vendor = 0; + int product = 0; + const char *name = "rdp"; + struct wlr_input_device *wlr_device = &device->wlr_input_device; + wlr_input_device_init(wlr_device, WLR_INPUT_DEVICE_KEYBOARD, + &input_device_impl, name, vendor, product); + + struct wlr_rdp_keyboard *keyboard = + calloc(1, sizeof(struct wlr_rdp_keyboard)); + if (!keyboard) { + wlr_log(WLR_ERROR, "Failed to allocate RDP pointer device"); + goto error; + } + wlr_device->keyboard = (struct wlr_keyboard *)keyboard; + wlr_keyboard_init(wlr_device->keyboard, NULL); + + wlr_log(WLR_DEBUG, "RDP keyboard layout: 0x%x type: 0x%x subtype: 0x%x " + "function_keys 0x%x", settings->KeyboardLayout, + settings->KeyboardType, settings->KeyboardSubType, + settings->KeyboardFunctionKey); + + // We need to set up an XKB context and jump through some hoops to convert + // RDP input events into scancodes + struct xkb_rule_names xkb_rule_names = { 0 }; + if (settings->KeyboardType <= 7) { + xkb_rule_names.model = rdp_keyboard_types[settings->KeyboardType]; + } + for (int i = 0; rdp_keyboards[i].rdp_layout_code; ++i) { + if (rdp_keyboards[i].rdp_layout_code == settings->KeyboardLayout) { + xkb_rule_names.layout = rdp_keyboards[i].xkb_layout; + xkb_rule_names.variant = rdp_keyboards[i].xkb_variant; + wlr_log(WLR_DEBUG, "Mapped RDP keyboard to xkb layout %s variant " + "%s", xkb_rule_names.layout, xkb_rule_names.variant); + break; + } + } + if (xkb_rule_names.layout) { + struct xkb_context *xkb_context = xkb_context_new(0); + if (!xkb_context) { + wlr_log(WLR_DEBUG, "Failed to allocate xkb context"); + goto error; + } + keyboard->keymap = + xkb_keymap_new_from_names(xkb_context, &xkb_rule_names, 0); + xkb_context_unref(xkb_context); + } + + wlr_keyboard_set_keymap(wlr_device->keyboard, keyboard->keymap); + + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_device); + return device; +error: + wlr_input_device_destroy(wlr_device); + return NULL; +} diff --git a/backend/rdp/listener.c b/backend/rdp/listener.c new file mode 100644 index 00000000..cfbdc537 --- /dev/null +++ b/backend/rdp/listener.c @@ -0,0 +1,61 @@ +#include <stdlib.h> +#include <wlr/util/log.h> +#include "backend/rdp.h" + +static int rdp_incoming_peer( + freerdp_listener *listener, freerdp_peer *client) { + struct wlr_rdp_backend *backend = + (struct wlr_rdp_backend *)listener->param4; + if (rdp_peer_init(client, backend) < 0) { + wlr_log(WLR_ERROR, "Error initializing incoming peer"); + return false; + } + return true; +} + +static int rdp_listener_activity(int fd, uint32_t mask, void *data) { + freerdp_listener *listener = data; + if (!(mask & WL_EVENT_READABLE)) { + return 0; + } + if (!listener->CheckFileDescriptor(listener)) { + wlr_log(WLR_ERROR, "Failed to check FreeRDP file descriptor"); + return -1; + } + return 0; +} + +bool rdp_configure_listener(struct wlr_rdp_backend *backend) { + backend->listener = freerdp_listener_new(); + if (!backend->listener) { + wlr_log(WLR_ERROR, "Failed to allocate FreeRDP listener"); + return false; + } + backend->listener->PeerAccepted = rdp_incoming_peer; + backend->listener->param4 = backend; + if (!backend->listener->Open(backend->listener, + backend->address, backend->port)) { + wlr_log(WLR_ERROR, "Failed to bind to RDP socket"); + return false; + } + int rcount = 0; + void *rfds[MAX_FREERDP_FDS]; + if (!backend->listener->GetFileDescriptor( + backend->listener, rfds, &rcount)) { + wlr_log(WLR_ERROR, "Failed to get FreeRDP file descriptors"); + return false; + } + struct wl_event_loop *event_loop = + wl_display_get_event_loop(backend->display); + int i; + for (i = 0; i < rcount; ++i) { + int fd = (int)(long)(rfds[i]); + backend->listener_events[i] = wl_event_loop_add_fd( + event_loop, fd, WL_EVENT_READABLE, rdp_listener_activity, + backend->listener); + } + for (; i < MAX_FREERDP_FDS; ++i) { + backend->listener_events[i] = NULL; + } + return true; +} diff --git a/backend/rdp/output.c b/backend/rdp/output.c new file mode 100644 index 00000000..4d5d259d --- /dev/null +++ b/backend/rdp/output.c @@ -0,0 +1,288 @@ +#include <assert.h> +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <stdlib.h> +#include <wayland-server.h> +#include <wlr/types/wlr_output.h> +#include <wlr/interfaces/wlr_output.h> +#include <wlr/util/log.h> +#include <wlr/render/wlr_renderer.h> +#include "backend/rdp.h" +#include "util/signal.h" + +static struct wlr_rdp_output *rdp_output_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_rdp(wlr_output)); + return (struct wlr_rdp_output *)wlr_output; +} + +static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, + unsigned int height) { + EGLint attribs[] = { + EGL_WIDTH, width, + EGL_HEIGHT, height, + EGL_NONE, + }; + EGLSurface surf = eglCreatePbufferSurface(egl->display, egl->config, attribs); + if (surf == EGL_NO_SURFACE) { + wlr_log(WLR_ERROR, "Failed to create EGL surface"); + return EGL_NO_SURFACE; + } + return surf; +} + +static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, + int32_t height, int32_t refresh) { + struct wlr_rdp_output *output = + rdp_output_from_output(wlr_output); + struct wlr_rdp_backend *backend = output->backend; + + if (refresh <= 0) { + refresh = 60 * 1000; // 60 Hz + } + + wlr_egl_destroy_surface(&backend->egl, output->egl_surface); + + output->egl_surface = egl_create_surface(&backend->egl, width, height); + if (output->egl_surface == EGL_NO_SURFACE) { + wlr_log(WLR_ERROR, "Failed to recreate EGL surface"); + wlr_output_destroy(wlr_output); + return false; + } + + output->frame_delay = 1000000 / refresh; + + if (output->shadow_surface) { + pixman_image_unref(output->shadow_surface); + } + output->shadow_surface = pixman_image_create_bits(PIXMAN_x8r8g8b8, + width, height, NULL, width * 4); + + wlr_output_update_custom_mode(&output->wlr_output, width, height, refresh); + return true; +} + +static void output_transform(struct wlr_output *wlr_output, + enum wl_output_transform transform) { + struct wlr_rdp_output *output = + rdp_output_from_output(wlr_output); + output->wlr_output.transform = transform; +} + +static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) { + struct wlr_rdp_output *output = + rdp_output_from_output(wlr_output); + return wlr_egl_make_current(&output->backend->egl, output->egl_surface, + buffer_age); +} + +static bool rfx_swap_buffers( + struct wlr_rdp_output *output, pixman_region32_t *damage) { + struct wlr_rdp_peer_context *context = output->context; + freerdp_peer *peer = context->peer; + rdpUpdate *update = peer->update; + + Stream_Clear(context->encode_stream); + Stream_SetPosition(context->encode_stream, 0); + int width = damage->extents.x2 - damage->extents.x1; + int height = damage->extents.y2 - damage->extents.y1; + + SURFACE_BITS_COMMAND cmd; + cmd.skipCompression = TRUE; + cmd.destLeft = damage->extents.x1; + cmd.destTop = damage->extents.y1; + cmd.destRight = damage->extents.x2; + cmd.destBottom = damage->extents.y2; + cmd.bmp.bpp = pixman_image_get_depth(output->shadow_surface); + cmd.bmp.codecID = peer->settings->RemoteFxCodecId; + cmd.bmp.width = width; + cmd.bmp.height = height; + + uint32_t *ptr = pixman_image_get_data(output->shadow_surface) + + damage->extents.x1 + damage->extents.y1 * + (pixman_image_get_stride(output->shadow_surface) / sizeof(uint32_t)); + + RFX_RECT *rfx_rect; + int nrects; + pixman_box32_t *rects = + pixman_region32_rectangles(damage, &nrects); + rfx_rect = realloc(context->rfx_rects, nrects * sizeof(*rfx_rect)); + if (rfx_rect == NULL) { + wlr_log(WLR_ERROR, "RDP swap buffers failed: could not realloc rects"); + return false; + } + context->rfx_rects = rfx_rect; + + for (int i = 0; i < nrects; ++i) { + pixman_box32_t *region = &rects[i]; + rfx_rect = &context->rfx_rects[i]; + rfx_rect->x = region->x1 - damage->extents.x1; + rfx_rect->y = region->y1 - damage->extents.y1; + rfx_rect->width = region->x2 - region->x1; + rfx_rect->height = region->y2 - region->y1; + } + + rfx_compose_message(context->rfx_context, context->encode_stream, + context->rfx_rects, nrects, (BYTE *)ptr, width, height, + pixman_image_get_stride(output->shadow_surface)); + cmd.bmp.bitmapDataLength = Stream_GetPosition(context->encode_stream); + cmd.bmp.bitmapData = Stream_Buffer(context->encode_stream); + + update->SurfaceBits(update->context, &cmd); + return true; +} + +static bool nsc_swap_buffers( + struct wlr_rdp_output *output, pixman_region32_t *damage) { + struct wlr_rdp_peer_context *context = output->context; + freerdp_peer *peer = context->peer; + rdpUpdate *update = peer->update; + + Stream_Clear(context->encode_stream); + Stream_SetPosition(context->encode_stream, 0); + int width = damage->extents.x2 - damage->extents.x1; + int height = damage->extents.y2 - damage->extents.y1; + + SURFACE_BITS_COMMAND cmd; + cmd.skipCompression = TRUE; + cmd.destLeft = damage->extents.x1; + cmd.destTop = damage->extents.y1; + cmd.destRight = damage->extents.x2; + cmd.destBottom = damage->extents.y2; + cmd.bmp.bpp = pixman_image_get_depth(output->shadow_surface); + cmd.bmp.codecID = peer->settings->NSCodecId; + cmd.bmp.width = width; + cmd.bmp.height = height; + + uint32_t *ptr = pixman_image_get_data(output->shadow_surface) + + damage->extents.x1 + damage->extents.y1 * + (pixman_image_get_stride(output->shadow_surface) / sizeof(uint32_t)); + + nsc_compose_message(context->nsc_context, context->encode_stream, + (BYTE *)ptr, width, height, + pixman_image_get_stride(output->shadow_surface)); + + cmd.bmp.bitmapDataLength = Stream_GetPosition(context->encode_stream); + cmd.bmp.bitmapData = Stream_Buffer(context->encode_stream); + + update->SurfaceBits(update->context, &cmd); + return true; +} + +static bool output_swap_buffers( + struct wlr_output *wlr_output, pixman_region32_t *damage) { + if (!pixman_region32_not_empty(damage)) { + return true; + } + + struct wlr_rdp_output *output = + rdp_output_from_output(wlr_output); + + // Update shadow buffer + int width = damage->extents.x2 - damage->extents.x1; + int height = damage->extents.y2 - damage->extents.y1; + struct wlr_renderer *renderer = + wlr_backend_get_renderer(&output->backend->backend); + // TODO performance: add support for flags + if (!wlr_renderer_read_pixels(renderer, WL_SHM_FORMAT_XRGB8888, + NULL, pixman_image_get_stride(output->shadow_surface), + width, height, damage->extents.x1, damage->extents.y1, + damage->extents.x1, damage->extents.y1, + pixman_image_get_data(output->shadow_surface))) { + return false; + } + + // Send along to clients + bool ret = false; + rdpSettings *settings = output->context->peer->settings; + if (settings->RemoteFxCodec) { + ret = rfx_swap_buffers(output, damage); + } else if (settings->NSCodec) { + ret = nsc_swap_buffers(output, damage); + } else { + // This would perform like ass so why bother + wlr_log(WLR_ERROR, "Raw updates are not supported; use rfx or nsc"); + } + wlr_output_send_present(wlr_output, NULL); + return ret; +} + +static void output_destroy(struct wlr_output *wlr_output) { + struct wlr_rdp_output *output = + rdp_output_from_output(wlr_output); + if (output->frame_timer) { + wl_event_source_remove(output->frame_timer); + } + wlr_egl_destroy_surface(&output->backend->egl, output->egl_surface); + if (output->shadow_surface) { + pixman_image_unref(output->shadow_surface); + } + free(output); +} + +static const struct wlr_output_impl output_impl = { + .set_custom_mode = output_set_custom_mode, + .transform = output_transform, + .destroy = output_destroy, + .make_current = output_make_current, + .swap_buffers = output_swap_buffers, +}; + +bool wlr_output_is_rdp(struct wlr_output *wlr_output) { + return wlr_output->impl == &output_impl; +} + +static int signal_frame(void *data) { + struct wlr_rdp_output *output = data; + wlr_output_send_frame(&output->wlr_output); + wl_event_source_timer_update(output->frame_timer, output->frame_delay); + return 0; +} + +struct wlr_rdp_output *wlr_rdp_output_create(struct wlr_rdp_backend *backend, + struct wlr_rdp_peer_context *context, unsigned int width, + unsigned int height) { + struct wlr_rdp_output *output = + calloc(1, sizeof(struct wlr_rdp_output)); + if (output == NULL) { + wlr_log(WLR_ERROR, "Failed to allocate wlr_rdp_output"); + return NULL; + } + output->backend = backend; + output->context = context; + wlr_output_init(&output->wlr_output, &backend->backend, &output_impl, + backend->display); + struct wlr_output *wlr_output = &output->wlr_output; + + output->egl_surface = egl_create_surface(&backend->egl, width, height); + if (output->egl_surface == EGL_NO_SURFACE) { + wlr_log(WLR_ERROR, "Failed to create EGL surface"); + goto error; + } + + output_set_custom_mode(wlr_output, width, height, 0); + strncpy(wlr_output->make, "RDP", sizeof(wlr_output->make)); + strncpy(wlr_output->model, "RDP", sizeof(wlr_output->model)); + snprintf(wlr_output->name, sizeof(wlr_output->name), "RDP-%d", + wl_list_length(&backend->clients)); + + if (!wlr_egl_make_current(&output->backend->egl, output->egl_surface, + NULL)) { + goto error; + } + + wlr_renderer_begin(backend->renderer, wlr_output->width, wlr_output->height); + wlr_renderer_clear(backend->renderer, (float[]){ 1.0, 1.0, 1.0, 1.0 }); + wlr_renderer_end(backend->renderer); + + struct wl_event_loop *ev = wl_display_get_event_loop(backend->display); + output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output); + wl_event_source_timer_update(output->frame_timer, output->frame_delay); + wlr_output_update_enabled(wlr_output, true); + wlr_signal_emit_safe(&backend->backend.events.new_output, wlr_output); + return output; + +error: + wlr_output_destroy(&output->wlr_output); + return NULL; +} diff --git a/backend/rdp/peer.c b/backend/rdp/peer.c new file mode 100644 index 00000000..350a4721 --- /dev/null +++ b/backend/rdp/peer.c @@ -0,0 +1,360 @@ +#define _POSIX_C_SOURCE 200809L +#include <linux/input.h> +#include <stdlib.h> +#include <string.h> +#include <wlr/types/wlr_output.h> +#include <wlr/interfaces/wlr_input_device.h> +#include <wlr/interfaces/wlr_keyboard.h> +#include <wlr/interfaces/wlr_output.h> +#include <wlr/util/log.h> +#include "backend/rdp.h" +#include "util/signal.h" + +static BOOL xf_peer_capabilities(freerdp_peer *client) { + return TRUE; +} + +static BOOL xf_peer_post_connect(freerdp_peer *client) { + return TRUE; +} + +static BOOL xf_peer_activate(freerdp_peer *client) { + struct wlr_rdp_peer_context *context = + (struct wlr_rdp_peer_context *)client->context; + struct wlr_rdp_backend *backend = context->backend; + rdpSettings *settings = client->settings; + + if (!settings->SurfaceCommandsEnabled) { + wlr_log(WLR_ERROR, "RDP peer does not support SurfaceCommands"); + return FALSE; + } + + context->output = wlr_rdp_output_create(backend, context, + (int)settings->DesktopWidth, (int)settings->DesktopHeight); + if (!context->output) { + wlr_log(WLR_ERROR, "Failed to allcoate output for RDP peer"); + return FALSE; + } + rfx_context_reset(context->rfx_context, + context->output->wlr_output.width, + context->output->wlr_output.height); + nsc_context_reset(context->nsc_context, + context->output->wlr_output.width, + context->output->wlr_output.height); + + if (context->flags & RDP_PEER_ACTIVATED) { + return TRUE; + } + + context->pointer = wlr_rdp_pointer_create(backend, context); + if (!context->pointer) { + wlr_log(WLR_ERROR, "Failed to allocate pointer for RDP peer"); + return FALSE; + } + + // Use wlroots' software cursors instead of remote cursors + POINTER_SYSTEM_UPDATE pointer_system; + rdpPointerUpdate *pointer = client->update->pointer; + pointer_system.type = SYSPTR_NULL; + pointer->PointerSystem(client->context, &pointer_system); + + context->keyboard = wlr_rdp_keyboard_create(backend, settings); + if (!context->keyboard) { + wlr_log(WLR_ERROR, "Failed to allocate keyboard for RDP peer"); + return FALSE; + } + + context->flags |= RDP_PEER_ACTIVATED; + return TRUE; +} + +static int xf_suppress_output(rdpContext *context, + BYTE allow, const RECTANGLE_16 *area) { + struct wlr_rdp_peer_context *peer_context = + (struct wlr_rdp_peer_context *)context; + if (allow) { + peer_context->flags |= RDP_PEER_OUTPUT_ENABLED; + } else { + peer_context->flags &= ~RDP_PEER_OUTPUT_ENABLED; + } + return true; +} + +static int xf_input_synchronize_event(rdpInput *input, UINT32 flags) { + struct wlr_rdp_peer_context *context = + (struct wlr_rdp_peer_context *)input->context; + wlr_output_damage_whole(&context->output->wlr_output); + return true; +} + +static inline int64_t timespec_to_msec(const struct timespec *a) { + return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000; +} + +static int xf_input_mouse_event(rdpInput *input, + UINT16 flags, UINT16 x, UINT16 y) { + struct wlr_rdp_peer_context *context = + (struct wlr_rdp_peer_context *)input->context; + struct wlr_input_device *wlr_device = &context->pointer->wlr_input_device; + struct wlr_pointer *pointer = wlr_device->pointer; + bool frame = false; + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + + if (flags & PTR_FLAGS_MOVE) { + struct wlr_event_pointer_motion_absolute event = { 0 }; + event.device = wlr_device; + event.time_msec = timespec_to_msec(&now); + event.x = x / (double)context->output->wlr_output.width; + event.y = y / (double)context->output->wlr_output.height; + wlr_signal_emit_safe(&pointer->events.motion_absolute, &event); + frame = true; + } + + uint32_t button = 0; + if (flags & PTR_FLAGS_BUTTON1) { + button = BTN_LEFT; + } else if (flags & PTR_FLAGS_BUTTON2) { + button = BTN_RIGHT; + } else if (flags & PTR_FLAGS_BUTTON3) { + button = BTN_MIDDLE; + } + + if (button) { + struct wlr_event_pointer_button event = { 0 }; + event.device = wlr_device; + event.time_msec = timespec_to_msec(&now); + event.button = button; + event.state = (flags & PTR_FLAGS_DOWN) ? + WLR_BUTTON_PRESSED : WLR_BUTTON_RELEASED; + wlr_signal_emit_safe(&pointer->events.button, &event); + frame = true; + } + + if (flags & PTR_FLAGS_WHEEL) { + double value = -(flags & 0xFF) / 120.0; + if (flags & PTR_FLAGS_WHEEL_NEGATIVE) { + value = -value; + } + struct wlr_event_pointer_axis event = { 0 }; + event.device = &context->pointer->wlr_input_device; + event.time_msec = timespec_to_msec(&now); + event.source = WLR_AXIS_SOURCE_WHEEL; + event.orientation = WLR_AXIS_ORIENTATION_VERTICAL; + event.delta = value; + event.delta_discrete = (int32_t)value; + wlr_signal_emit_safe(&pointer->events.axis, &event); + frame = true; + } + + if (frame) { + wlr_signal_emit_safe(&pointer->events.frame, pointer); + } + + return true; +} + +static int xf_input_extended_mouse_event( + rdpInput *input, UINT16 flags, UINT16 x, UINT16 y) { + struct wlr_rdp_peer_context *context = + (struct wlr_rdp_peer_context *)input->context; + struct wlr_input_device *wlr_device = &context->pointer->wlr_input_device; + struct wlr_pointer *pointer = wlr_device->pointer; + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + struct wlr_event_pointer_motion_absolute event = { 0 }; + event.device = wlr_device; + event.time_msec = timespec_to_msec(&now); + event.x = x / (double)context->output->wlr_output.width; + event.y = y / (double)context->output->wlr_output.height; + wlr_signal_emit_safe(&pointer->events.motion_absolute, &event); + wlr_signal_emit_safe(&pointer->events.frame, pointer); + return true; +} + +static int xf_input_keyboard_event(rdpInput *input, UINT16 flags, UINT16 code) { + struct wlr_rdp_peer_context *context = + (struct wlr_rdp_peer_context *)input->context; + struct wlr_input_device *wlr_device = &context->keyboard->wlr_input_device; + struct wlr_keyboard *keyboard = wlr_device->keyboard; + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + + if (!(context->flags & RDP_PEER_ACTIVATED)) { + return true; + } + + bool notify = false; + enum wlr_key_state state; + if ((flags & KBD_FLAGS_DOWN)) { + state = WLR_KEY_PRESSED; + notify = true; + } else if ((flags & KBD_FLAGS_RELEASE)) { + state = WLR_KEY_RELEASED; + notify = true; + } + + if (notify) { + uint32_t full_code = code; + if (flags & KBD_FLAGS_EXTENDED) { + full_code |= KBD_FLAGS_EXTENDED; + } + uint32_t vk_code = GetVirtualKeyCodeFromVirtualScanCode(full_code, 4); + if (flags & KBD_FLAGS_EXTENDED) { + vk_code |= KBDEXT; + } + uint32_t scan_code = GetKeycodeFromVirtualKeyCode( + vk_code, KEYCODE_TYPE_EVDEV); + struct wlr_event_keyboard_key event = { 0 }; + event.time_msec = timespec_to_msec(&now); + event.keycode = scan_code - 8; + event.state = state; + event.update_state = true; + wlr_keyboard_notify_key(keyboard, &event); + } + + return true; +} + +static int xf_input_unicode_keyboard_event(rdpInput *input, + UINT16 flags, UINT16 code) { + wlr_log(WLR_DEBUG, "Unhandled RDP unicode keyboard event " + "(flags:0x%X code:0x%X)\n", flags, code); + return true; +} + +static int rdp_client_activity(int fd, uint32_t mask, void *data) { + freerdp_peer *client = (freerdp_peer *)data; + if (!client->CheckFileDescriptor(client)) { + wlr_log(WLR_ERROR, + "Unable to check client file descriptor for %p", client); + freerdp_peer_context_free(client); + freerdp_peer_free(client); + } + return 0; +} + +static int rdp_peer_context_new( + freerdp_peer *client, struct wlr_rdp_peer_context *context) { + context->peer = client; + context->flags = RDP_PEER_OUTPUT_ENABLED; + context->rfx_context = rfx_context_new(TRUE); + if (!context->rfx_context) { + return false; + } + context->rfx_context->mode = RLGR3; + context->rfx_context->width = client->settings->DesktopWidth; + context->rfx_context->height = client->settings->DesktopHeight; + rfx_context_set_pixel_format(context->rfx_context, PIXEL_FORMAT_BGRA32); + + context->nsc_context = nsc_context_new(); + if (!context->nsc_context) { + rfx_context_free(context->rfx_context); + return false; + } + + nsc_context_set_pixel_format(context->nsc_context, PIXEL_FORMAT_BGRA32); + + context->encode_stream = Stream_New(NULL, 65536); + if (!context->encode_stream) { + nsc_context_free(context->nsc_context); + rfx_context_free(context->rfx_context); + return false; + } + return true; +} + +static void rdp_peer_context_free( + freerdp_peer *client, struct wlr_rdp_peer_context *context) { + if (!context) { + return; + } + + for (int i = 0; i < MAX_FREERDP_FDS; ++i) { + if (context->events[i]) { + wl_event_source_remove(context->events[i]); + } + } + + if (context->flags & RDP_PEER_ACTIVATED) { + wlr_output_destroy(&context->output->wlr_output); + wlr_input_device_destroy(&context->pointer->wlr_input_device); + wlr_input_device_destroy(&context->keyboard->wlr_input_device); + } + + wl_list_remove(&context->link); + wlr_output_destroy(&context->output->wlr_output); + + Stream_Free(context->encode_stream, TRUE); + nsc_context_free(context->nsc_context); + rfx_context_free(context->rfx_context); + free(context->rfx_rects); +} + +int rdp_peer_init(freerdp_peer *client, + struct wlr_rdp_backend *backend) { + client->ContextSize = sizeof(struct wlr_rdp_peer_context); + client->ContextNew = (psPeerContextNew)rdp_peer_context_new; + client->ContextFree = (psPeerContextFree)rdp_peer_context_free; + freerdp_peer_context_new(client); + + struct wlr_rdp_peer_context *peer_context = + (struct wlr_rdp_peer_context *)client->context; + peer_context->backend = backend; + + client->settings->CertificateFile = strdup(backend->tls_cert_path); + client->settings->PrivateKeyFile = strdup(backend->tls_key_path); + client->settings->NlaSecurity = FALSE; + + if (!client->Initialize(client)) { + wlr_log(WLR_ERROR, "Failed to initialize FreeRDP peer"); + goto err_init; + } + + client->settings->OsMajorType = OSMAJORTYPE_UNIX; + client->settings->OsMinorType = OSMINORTYPE_PSEUDO_XSERVER; + client->settings->ColorDepth = 32; + client->settings->RefreshRect = TRUE; + client->settings->RemoteFxCodec = TRUE; + client->settings->NSCodec = TRUE; + client->settings->FrameMarkerCommandEnabled = TRUE; + client->settings->SurfaceFrameMarkerEnabled = TRUE; + + client->Capabilities = xf_peer_capabilities; + client->PostConnect = xf_peer_post_connect; + client->Activate = xf_peer_activate; + + client->update->SuppressOutput = (pSuppressOutput)xf_suppress_output; + + client->input->SynchronizeEvent = xf_input_synchronize_event; + client->input->MouseEvent = xf_input_mouse_event; + client->input->ExtendedMouseEvent = xf_input_extended_mouse_event; + client->input->KeyboardEvent = xf_input_keyboard_event; + client->input->UnicodeKeyboardEvent = xf_input_unicode_keyboard_event; + + int rcount = 0; + void *rfds[MAX_FREERDP_FDS]; + if (!client->GetFileDescriptor(client, rfds, &rcount)) { + wlr_log(WLR_ERROR, "Unable to retrieve client file descriptors"); + goto err_init; + } + struct wl_event_loop *event_loop = + wl_display_get_event_loop(backend->display); + int i; + for (i = 0; i < rcount; ++i) { + int fd = (int)(long)(rfds[i]); + peer_context->events[i] = wl_event_loop_add_fd( + event_loop, fd, WL_EVENT_READABLE, rdp_client_activity, + client); + } + for (; i < MAX_FREERDP_FDS; ++i) { + peer_context->events[i] = NULL; + } + + wl_list_insert(&backend->clients, &peer_context->link); + return 0; + +err_init: + client->Close(client); + return -1; +} diff --git a/backend/rdp/pointer.c b/backend/rdp/pointer.c new file mode 100644 index 00000000..31186669 --- /dev/null +++ b/backend/rdp/pointer.c @@ -0,0 +1,40 @@ +#define _POSIX_C_SOURCE 200809L +#include <stdlib.h> +#include <string.h> +#include <wayland-server.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_pointer.h> +#include <wlr/interfaces/wlr_pointer.h> +#include <wlr/interfaces/wlr_input_device.h> +#include <wlr/util/log.h> +#include "backend/rdp.h" +#include "util/signal.h" + +static struct wlr_input_device_impl input_device_impl = { 0 }; + +struct wlr_rdp_input_device *wlr_rdp_pointer_create( + struct wlr_rdp_backend *backend, struct wlr_rdp_peer_context *context) { + struct wlr_rdp_input_device *device = + calloc(1, sizeof(struct wlr_rdp_input_device)); + if (!device) { + wlr_log(WLR_ERROR, "Failed to allocate RDP input device"); + return NULL; + } + + int vendor = 0; + int product = 0; + const char *name = "rdp"; + struct wlr_input_device *wlr_device = &device->wlr_input_device; + wlr_input_device_init(wlr_device, WLR_INPUT_DEVICE_POINTER, + &input_device_impl, name, vendor, product); + + if (!(wlr_device->pointer = calloc(1, sizeof(struct wlr_pointer)))) { + wlr_log(WLR_ERROR, "Failed to allocate RDP pointer device"); + return NULL; + } + wlr_device->output_name = strdup(context->output->wlr_output.name); + wlr_pointer_init(wlr_device->pointer, NULL); + + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_device); + return device; +} |