blob: 942af50eb471a37d594fdf46dd42d1c4ed6d88f7 [file] [log] [blame]
Hardeninga83409c2013-04-01 23:43:58 +02001/*
2 * Copyright © 2013 Hardening <rdp.effort@gmail.com>
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 */
22
Daniel Stonec228e232013-05-22 18:03:19 +030023#include "config.h"
Hardeninga83409c2013-04-01 23:43:58 +020024
25#include <stdlib.h>
26#include <string.h>
27#include <errno.h>
28#include <linux/input.h>
29
30#include <freerdp/freerdp.h>
31#include <freerdp/listener.h>
32#include <freerdp/update.h>
33#include <freerdp/input.h>
34#include <freerdp/codec/color.h>
35#include <freerdp/codec/rfx.h>
36#include <freerdp/codec/nsc.h>
Hardening4a3c1502013-04-06 23:39:26 +020037#include <winpr/input.h>
Hardeninga83409c2013-04-01 23:43:58 +020038
39#include "compositor.h"
40#include "pixman-renderer.h"
41
42#define MAX_FREERDP_FDS 32
Hardeningb60e46f2013-06-03 22:55:47 +020043#define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int(10)
Hardeninga83409c2013-04-01 23:43:58 +020044
45struct rdp_compositor_config {
46 int width;
47 int height;
48 char *bind_address;
49 int port;
50 char *rdp_key;
51 char *server_cert;
52 char *server_key;
53 char *extra_modes;
54 int env_socket;
55};
56
57struct rdp_output;
58
59struct rdp_compositor {
60 struct weston_compositor base;
Hardeninga83409c2013-04-01 23:43:58 +020061
62 freerdp_listener *listener;
63 struct wl_event_source *listener_events[MAX_FREERDP_FDS];
64 struct rdp_output *output;
65
66 char *server_cert;
67 char *server_key;
68 char *rdp_key;
69 int tls_enabled;
70};
71
72enum peer_item_flags {
73 RDP_PEER_ACTIVATED = (1 << 0),
74 RDP_PEER_OUTPUT_ENABLED = (1 << 1),
75};
76
77struct rdp_peers_item {
78 int flags;
79 freerdp_peer *peer;
80 struct weston_seat seat;
81
82 struct wl_list link;
83};
84
85struct rdp_output {
86 struct weston_output base;
87 struct wl_event_source *finish_frame_timer;
88 pixman_image_t *shadow_surface;
89
90 struct wl_list peers;
91};
92
93struct rdp_peer_context {
94 rdpContext _p;
Hardeningb8f03aa2013-05-26 23:34:00 +020095
Hardeninga83409c2013-04-01 23:43:58 +020096 struct rdp_compositor *rdpCompositor;
Hardeninga83409c2013-04-01 23:43:58 +020097 struct wl_event_source *events[MAX_FREERDP_FDS];
Hardeninga83409c2013-04-01 23:43:58 +020098 RFX_CONTEXT *rfx_context;
99 wStream *encode_stream;
100 RFX_RECT *rfx_rects;
101 NSC_CONTEXT *nsc_context;
102
103 struct rdp_peers_item item;
104};
105typedef struct rdp_peer_context RdpPeerContext;
106
107static void
108rdp_compositor_config_init(struct rdp_compositor_config *config) {
109 config->width = 640;
110 config->height = 480;
111 config->bind_address = NULL;
112 config->port = 3389;
113 config->rdp_key = NULL;
114 config->server_cert = NULL;
115 config->server_key = NULL;
116 config->extra_modes = NULL;
117 config->env_socket = 0;
118}
119
120static void
121rdp_peer_refresh_rfx(pixman_region32_t *damage, pixman_image_t *image, freerdp_peer *peer)
122{
123 int width, height, nrects, i;
124 pixman_box32_t *region, *rects;
125 uint32_t *ptr;
126 RFX_RECT *rfxRect;
127 rdpUpdate *update = peer->update;
128 SURFACE_BITS_COMMAND *cmd = &update->surface_bits_command;
129 RdpPeerContext *context = (RdpPeerContext *)peer->context;
130
Hardeninga1ce6cd2013-05-22 23:40:16 +0200131 Stream_Clear(context->encode_stream);
132 Stream_SetPosition(context->encode_stream, 0);
Hardeninga83409c2013-04-01 23:43:58 +0200133
134 width = (damage->extents.x2 - damage->extents.x1);
135 height = (damage->extents.y2 - damage->extents.y1);
136
137 cmd->destLeft = damage->extents.x1;
138 cmd->destTop = damage->extents.y1;
139 cmd->destRight = damage->extents.x2;
140 cmd->destBottom = damage->extents.y2;
141 cmd->bpp = 32;
142 cmd->codecID = peer->settings->RemoteFxCodecId;
143 cmd->width = width;
144 cmd->height = height;
145
146 ptr = pixman_image_get_data(image) + damage->extents.x1 +
147 damage->extents.y1 * (pixman_image_get_stride(image) / sizeof(uint32_t));
148
149 rects = pixman_region32_rectangles(damage, &nrects);
150 context->rfx_rects = realloc(context->rfx_rects, nrects * sizeof *rfxRect);
151
152 for (i = 0; i < nrects; i++) {
153 region = &rects[i];
154 rfxRect = &context->rfx_rects[i];
155
156 rfxRect->x = (region->x1 - damage->extents.x1);
157 rfxRect->y = (region->y1 - damage->extents.y1);
158 rfxRect->width = (region->x2 - region->x1);
159 rfxRect->height = (region->y2 - region->y1);
160 }
161
162 rfx_compose_message(context->rfx_context, context->encode_stream, context->rfx_rects, nrects,
163 (BYTE *)ptr, width, height,
164 pixman_image_get_stride(image)
165 );
166
Hardeninga1ce6cd2013-05-22 23:40:16 +0200167 cmd->bitmapDataLength = Stream_GetPosition(context->encode_stream);
168 cmd->bitmapData = Stream_Buffer(context->encode_stream);
Hardeninga83409c2013-04-01 23:43:58 +0200169
170 update->SurfaceBits(update->context, cmd);
171}
172
173
174static void
175rdp_peer_refresh_nsc(pixman_region32_t *damage, pixman_image_t *image, freerdp_peer *peer)
176{
177 int width, height;
178 uint32_t *ptr;
179 rdpUpdate *update = peer->update;
180 SURFACE_BITS_COMMAND *cmd = &update->surface_bits_command;
181 RdpPeerContext *context = (RdpPeerContext *)peer->context;
182
Hardeninga1ce6cd2013-05-22 23:40:16 +0200183 Stream_Clear(context->encode_stream);
184 Stream_SetPosition(context->encode_stream, 0);
Hardeninga83409c2013-04-01 23:43:58 +0200185
186 width = (damage->extents.x2 - damage->extents.x1);
187 height = (damage->extents.y2 - damage->extents.y1);
188
189 cmd->destLeft = damage->extents.x1;
190 cmd->destTop = damage->extents.y1;
191 cmd->destRight = damage->extents.x2;
192 cmd->destBottom = damage->extents.y2;
193 cmd->bpp = 32;
194 cmd->codecID = peer->settings->NSCodecId;
195 cmd->width = width;
196 cmd->height = height;
197
198 ptr = pixman_image_get_data(image) + damage->extents.x1 +
199 damage->extents.y1 * (pixman_image_get_stride(image) / sizeof(uint32_t));
200
201 nsc_compose_message(context->nsc_context, context->encode_stream, (BYTE *)ptr,
202 cmd->width, cmd->height,
203 pixman_image_get_stride(image));
Hardeninga1ce6cd2013-05-22 23:40:16 +0200204 cmd->bitmapDataLength = Stream_GetPosition(context->encode_stream);
205 cmd->bitmapData = Stream_Buffer(context->encode_stream);
Hardeninga83409c2013-04-01 23:43:58 +0200206 update->SurfaceBits(update->context, cmd);
207}
208
209static void
Hardeningfe36a132013-05-22 23:40:20 +0200210pixman_image_flipped_subrect(const pixman_box32_t *rect, pixman_image_t *img, BYTE *dest) {
211 int stride = pixman_image_get_stride(img);
212 int h;
213 int toCopy = (rect->x2 - rect->x1) * 4;
214 int height = (rect->y2 - rect->y1);
215 const BYTE *src = (const BYTE *)pixman_image_get_data(img);
216 src += ((rect->y2-1) * stride) + (rect->x1 * 4);
217
218 for (h = 0; h < height; h++, src -= stride, dest += toCopy)
219 memcpy(dest, src, toCopy);
220}
221
222static void
Hardeninga83409c2013-04-01 23:43:58 +0200223rdp_peer_refresh_raw(pixman_region32_t *region, pixman_image_t *image, freerdp_peer *peer)
224{
Hardeninga83409c2013-04-01 23:43:58 +0200225 rdpUpdate *update = peer->update;
226 SURFACE_BITS_COMMAND *cmd = &update->surface_bits_command;
Hardeningfe36a132013-05-22 23:40:20 +0200227 SURFACE_FRAME_MARKER *marker = &update->surface_frame_marker;
228 pixman_box32_t *rect, subrect;
229 int nrects, i;
230 int heightIncrement, remainingHeight, top;
231
232 rect = pixman_region32_rectangles(region, &nrects);
233 if (!nrects)
234 return;
235
236 marker->frameId++;
237 marker->frameAction = SURFACECMD_FRAMEACTION_BEGIN;
238 update->SurfaceFrameMarker(peer->context, marker);
Hardeninga83409c2013-04-01 23:43:58 +0200239
240 cmd->bpp = 32;
241 cmd->codecID = 0;
Hardeningfe36a132013-05-22 23:40:20 +0200242
243 for (i = 0; i < nrects; i++, rect++) {
244 /*weston_log("rect(%d,%d, %d,%d)\n", rect->x1, rect->y1, rect->x2, rect->y2);*/
245 cmd->destLeft = rect->x1;
246 cmd->destRight = rect->x2;
247 cmd->width = rect->x2 - rect->x1;
248
249 heightIncrement = peer->settings->MultifragMaxRequestSize / (16 + cmd->width * 4);
250 remainingHeight = rect->y2 - rect->y1;
251 top = rect->y1;
252
253 subrect.x1 = rect->x1;
254 subrect.x2 = rect->x2;
255
256 while (remainingHeight) {
257 cmd->height = (remainingHeight > heightIncrement) ? heightIncrement : remainingHeight;
258 cmd->destTop = top;
259 cmd->destBottom = top + cmd->height;
260 cmd->bitmapDataLength = cmd->width * cmd->height * 4;
261 cmd->bitmapData = (BYTE *)realloc(cmd->bitmapData, cmd->bitmapDataLength);
262
263 subrect.y1 = top;
264 subrect.y2 = top + cmd->height;
265 pixman_image_flipped_subrect(&subrect, image, cmd->bitmapData);
266
267 /*weston_log("* sending (%d,%d, %d,%d)\n", subrect.x1, subrect.y1, subrect.x2, subrect.y2); */
268 update->SurfaceBits(peer->context, cmd);
269
270 remainingHeight -= cmd->height;
271 top += cmd->height;
272 }
273 }
274
275 marker->frameAction = SURFACECMD_FRAMEACTION_END;
276 update->SurfaceFrameMarker(peer->context, marker);
Hardeninga83409c2013-04-01 23:43:58 +0200277}
278
279static void
280rdp_peer_refresh_region(pixman_region32_t *region, freerdp_peer *peer)
281{
282 RdpPeerContext *context = (RdpPeerContext *)peer->context;
283 struct rdp_output *output = context->rdpCompositor->output;
284 rdpSettings *settings = peer->settings;
Hardeninga83409c2013-04-01 23:43:58 +0200285
Hardeningfe36a132013-05-22 23:40:20 +0200286 if (settings->RemoteFxCodec)
287 rdp_peer_refresh_rfx(region, output->shadow_surface, peer);
288 else if (settings->NSCodec)
289 rdp_peer_refresh_nsc(region, output->shadow_surface, peer);
290 else
Hardeninga83409c2013-04-01 23:43:58 +0200291 rdp_peer_refresh_raw(region, output->shadow_surface, peer);
Hardeninga83409c2013-04-01 23:43:58 +0200292}
293
Jonas Ådahle5a12252013-04-05 23:07:11 +0200294static void
295rdp_output_start_repaint_loop(struct weston_output *output)
296{
297 uint32_t msec;
298 struct timeval tv;
299
300 gettimeofday(&tv, NULL);
301 msec = tv.tv_sec * 1000 + tv.tv_usec / 1000;
302 weston_output_finish_frame(output, msec);
303}
Hardeninga83409c2013-04-01 23:43:58 +0200304
David Herrmann1edf44c2013-10-22 17:11:26 +0200305static int
Hardeninga83409c2013-04-01 23:43:58 +0200306rdp_output_repaint(struct weston_output *output_base, pixman_region32_t *damage)
307{
308 struct rdp_output *output = container_of(output_base, struct rdp_output, base);
309 struct weston_compositor *ec = output->base.compositor;
310 struct rdp_peers_item *outputPeer;
311
312 pixman_renderer_output_set_buffer(output_base, output->shadow_surface);
313 ec->renderer->repaint_output(&output->base, damage);
314
315 wl_list_for_each(outputPeer, &output->peers, link) {
316 if ((outputPeer->flags & RDP_PEER_ACTIVATED) &&
317 (outputPeer->flags & RDP_PEER_OUTPUT_ENABLED))
318 {
319 rdp_peer_refresh_region(damage, outputPeer->peer);
320 }
321 }
322
323 pixman_region32_subtract(&ec->primary_plane.damage,
324 &ec->primary_plane.damage, damage);
325
326 wl_event_source_timer_update(output->finish_frame_timer, 16);
David Herrmann1edf44c2013-10-22 17:11:26 +0200327 return 0;
Hardeninga83409c2013-04-01 23:43:58 +0200328}
329
330static void
331rdp_output_destroy(struct weston_output *output_base)
332{
333 struct rdp_output *output = (struct rdp_output *)output_base;
334
335 wl_event_source_remove(output->finish_frame_timer);
336 free(output);
337}
338
339static int
340finish_frame_handler(void *data)
341{
Jonas Ådahle5a12252013-04-05 23:07:11 +0200342 rdp_output_start_repaint_loop(data);
Hardeninga83409c2013-04-01 23:43:58 +0200343
344 return 1;
345}
346
347
348static struct weston_mode *
349find_matching_mode(struct weston_output *output, struct weston_mode *target) {
350 struct weston_mode *local;
351
352 wl_list_for_each(local, &output->mode_list, link) {
353 if((local->width == target->width) && (local->height == target->height))
354 return local;
355 }
356 return 0;
357}
358
359static int
360rdp_switch_mode(struct weston_output *output, struct weston_mode *target_mode) {
361 struct rdp_output *rdpOutput = container_of(output, struct rdp_output, base);
362 struct rdp_peers_item *rdpPeer;
363 rdpSettings *settings;
364 pixman_image_t *new_shadow_buffer;
365 struct weston_mode *local_mode;
366
367 local_mode = find_matching_mode(output, target_mode);
368 if(!local_mode) {
369 weston_log("mode %dx%d not available\n", target_mode->width, target_mode->height);
370 return -ENOENT;
371 }
372
Hardeningff39efa2013-09-18 23:56:35 +0200373 if(local_mode == output->current_mode)
Hardeninga83409c2013-04-01 23:43:58 +0200374 return 0;
375
Hardening57388e42013-09-18 23:56:36 +0200376 output->current_mode->flags &= ~WL_OUTPUT_MODE_CURRENT;
377
Hardeningff39efa2013-09-18 23:56:35 +0200378 output->current_mode = local_mode;
Hardening57388e42013-09-18 23:56:36 +0200379 output->current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
Hardeninga83409c2013-04-01 23:43:58 +0200380
381 pixman_renderer_output_destroy(output);
382 pixman_renderer_output_create(output);
383
384 new_shadow_buffer = pixman_image_create_bits(PIXMAN_x8r8g8b8, target_mode->width,
385 target_mode->height, 0, target_mode->width * 4);
386 pixman_image_composite32(PIXMAN_OP_SRC, rdpOutput->shadow_surface, 0, new_shadow_buffer,
387 0, 0, 0, 0, 0, 0, target_mode->width, target_mode->height);
388 pixman_image_unref(rdpOutput->shadow_surface);
389 rdpOutput->shadow_surface = new_shadow_buffer;
390
391 wl_list_for_each(rdpPeer, &rdpOutput->peers, link) {
392 settings = rdpPeer->peer->settings;
393 if(!settings->DesktopResize) {
394 /* too bad this peer does not support desktop resize */
395 rdpPeer->peer->Close(rdpPeer->peer);
396 } else {
397 settings->DesktopWidth = target_mode->width;
398 settings->DesktopHeight = target_mode->height;
399 rdpPeer->peer->update->DesktopResize(rdpPeer->peer->context);
400 }
401 }
402 return 0;
403}
404
405static int
406parse_extra_modes(const char *modes_str, struct rdp_output *output) {
407 const char *startAt = modes_str;
408 const char *nextPos;
409 int w, h;
410 struct weston_mode *mode;
411
412 while(startAt && *startAt) {
413 nextPos = strchr(startAt, 'x');
414 if(!nextPos)
415 return -1;
416
417 w = strtoul(startAt, NULL, 0);
418 startAt = nextPos + 1;
419 if(!*startAt)
420 return -1;
421
422 h = strtoul(startAt, NULL, 0);
423
424 if(!w || (w > 3000) || !h || (h > 3000))
425 return -1;
426 mode = malloc(sizeof *mode);
427 if(!mode)
428 return -1;
429
430 mode->width = w;
431 mode->height = h;
432 mode->refresh = 5;
433 mode->flags = 0;
434 wl_list_insert(&output->base.mode_list, &mode->link);
435
436 startAt = strchr(startAt, ',');
437 if(startAt && *startAt == ',')
438 startAt++;
439 }
440 return 0;
441}
442static int
443rdp_compositor_create_output(struct rdp_compositor *c, int width, int height,
444 const char *extraModes)
445{
446 struct rdp_output *output;
447 struct wl_event_loop *loop;
448 struct weston_mode *currentMode, *next;
449
Peter Huttererf3d62272013-08-08 11:57:05 +1000450 output = zalloc(sizeof *output);
Hardeninga83409c2013-04-01 23:43:58 +0200451 if (output == NULL)
452 return -1;
Hardeninga83409c2013-04-01 23:43:58 +0200453
454 wl_list_init(&output->peers);
455 wl_list_init(&output->base.mode_list);
456
457 currentMode = malloc(sizeof *currentMode);
458 if(!currentMode)
459 goto out_free_output;
460 currentMode->flags = WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
461 currentMode->width = width;
462 currentMode->height = height;
463 currentMode->refresh = 5;
464 wl_list_insert(&output->base.mode_list, &currentMode->link);
465
466 if(parse_extra_modes(extraModes, output) < 0) {
467 weston_log("invalid extra modes\n");
468 goto out_free_output_and_modes;
469 }
470
Hardening57388e42013-09-18 23:56:36 +0200471 output->base.current_mode = output->base.native_mode = currentMode;
Hardeninga83409c2013-04-01 23:43:58 +0200472 weston_output_init(&output->base, &c->base, 0, 0, width, height,
Kristian Høgsberg785e1f32013-05-22 21:53:09 -0400473 WL_OUTPUT_TRANSFORM_NORMAL, 1);
Hardeninga83409c2013-04-01 23:43:58 +0200474
475 output->base.make = "weston";
476 output->base.model = "rdp";
477 output->shadow_surface = pixman_image_create_bits(PIXMAN_x8r8g8b8,
478 width, height,
479 NULL,
480 width * 4);
481 if (output->shadow_surface == NULL) {
482 weston_log("Failed to create surface for frame buffer.\n");
483 goto out_output;
484 }
485
486 if (pixman_renderer_output_create(&output->base) < 0)
487 goto out_shadow_surface;
488
Hardeninga83409c2013-04-01 23:43:58 +0200489 loop = wl_display_get_event_loop(c->base.wl_display);
490 output->finish_frame_timer = wl_event_loop_add_timer(loop, finish_frame_handler, output);
491
Jonas Ådahle5a12252013-04-05 23:07:11 +0200492 output->base.start_repaint_loop = rdp_output_start_repaint_loop;
Hardeninga83409c2013-04-01 23:43:58 +0200493 output->base.repaint = rdp_output_repaint;
494 output->base.destroy = rdp_output_destroy;
495 output->base.assign_planes = NULL;
496 output->base.set_backlight = NULL;
497 output->base.set_dpms = NULL;
498 output->base.switch_mode = rdp_switch_mode;
499 c->output = output;
500
501 wl_list_insert(c->base.output_list.prev, &output->base.link);
502 return 0;
503
504out_shadow_surface:
505 pixman_image_unref(output->shadow_surface);
506out_output:
507 weston_output_destroy(&output->base);
508out_free_output_and_modes:
509 wl_list_for_each_safe(currentMode, next, &output->base.mode_list, link)
510 free(currentMode);
511out_free_output:
512 free(output);
513 return -1;
514}
515
516static void
517rdp_restore(struct weston_compositor *ec)
518{
519}
520
521static void
522rdp_destroy(struct weston_compositor *ec)
523{
Hardeninga83409c2013-04-01 23:43:58 +0200524 weston_compositor_shutdown(ec);
525
526 free(ec);
527}
528
529static
530int rdp_listener_activity(int fd, uint32_t mask, void *data) {
531 freerdp_listener* instance = (freerdp_listener *)data;
532
533 if (!(mask & WL_EVENT_READABLE))
534 return 0;
535 if (!instance->CheckFileDescriptor(instance))
536 {
537 weston_log("failed to check FreeRDP file descriptor\n");
538 return -1;
539 }
540 return 0;
541}
542
543static
544int rdp_implant_listener(struct rdp_compositor *c, freerdp_listener* instance) {
545 int i, fd;
546 int rcount = 0;
547 void* rfds[MAX_FREERDP_FDS];
548 struct wl_event_loop *loop;
549
550 if (!instance->GetFileDescriptor(instance, rfds, &rcount)) {
551 weston_log("Failed to get FreeRDP file descriptor\n");
552 return -1;
553 }
554
555 loop = wl_display_get_event_loop(c->base.wl_display);
556 for (i = 0; i < rcount; i++) {
557 fd = (int)(long)(rfds[i]);
558 c->listener_events[i] = wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
559 rdp_listener_activity, instance);
560 }
561
562 for( ; i < MAX_FREERDP_FDS; i++)
563 c->listener_events[i] = 0;
564 return 0;
565}
566
567
568static void
569rdp_peer_context_new(freerdp_peer* client, RdpPeerContext* context)
570{
571 context->item.peer = client;
Hardening58bcc362013-08-17 00:30:31 +0200572 context->item.flags = RDP_PEER_OUTPUT_ENABLED;
Hardeninga83409c2013-04-01 23:43:58 +0200573
574 context->rfx_context = rfx_context_new();
575 context->rfx_context->mode = RLGR3;
576 context->rfx_context->width = client->settings->DesktopWidth;
577 context->rfx_context->height = client->settings->DesktopHeight;
578 rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_B8G8R8A8);
579
580 context->nsc_context = nsc_context_new();
Hardening827358e2013-05-22 23:40:18 +0200581 nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_B8G8R8A8);
Hardeninga83409c2013-04-01 23:43:58 +0200582
Hardeninga1ce6cd2013-05-22 23:40:16 +0200583 context->encode_stream = Stream_New(NULL, 65536);
Hardeninga83409c2013-04-01 23:43:58 +0200584}
585
586static void
587rdp_peer_context_free(freerdp_peer* client, RdpPeerContext* context)
588{
589 int i;
590 if(!context)
591 return;
592
593 wl_list_remove(&context->item.link);
594 for(i = 0; i < MAX_FREERDP_FDS; i++) {
Hardeningb8f03aa2013-05-26 23:34:00 +0200595 if (context->events[i])
Hardeninga83409c2013-04-01 23:43:58 +0200596 wl_event_source_remove(context->events[i]);
597 }
598
599 if(context->item.flags & RDP_PEER_ACTIVATED)
600 weston_seat_release(&context->item.seat);
Hardeninga1ce6cd2013-05-22 23:40:16 +0200601 Stream_Free(context->encode_stream, TRUE);
Hardeninga83409c2013-04-01 23:43:58 +0200602 nsc_context_free(context->nsc_context);
603 rfx_context_free(context->rfx_context);
604 free(context->rfx_rects);
605}
606
607
608static int
609rdp_client_activity(int fd, uint32_t mask, void *data) {
610 freerdp_peer* client = (freerdp_peer *)data;
611
612 if (!client->CheckFileDescriptor(client)) {
613 weston_log("unable to checkDescriptor for %p\n", client);
614 goto out_clean;
615 }
616 return 0;
617
618out_clean:
619 freerdp_peer_context_free(client);
620 freerdp_peer_free(client);
621 return 0;
622}
623
624static BOOL
625xf_peer_capabilities(freerdp_peer* client)
626{
627 return TRUE;
628}
629
Hardening4a3c1502013-04-06 23:39:26 +0200630
Hardeninga83409c2013-04-01 23:43:58 +0200631struct rdp_to_xkb_keyboard_layout {
Hardening4a3c1502013-04-06 23:39:26 +0200632 UINT32 rdpLayoutCode;
633 char *xkbLayout;
Hardeninga83409c2013-04-01 23:43:58 +0200634};
635
636/* picked from http://technet.microsoft.com/en-us/library/cc766503(WS.10).aspx */
637static struct rdp_to_xkb_keyboard_layout rdp_keyboards[] = {
638 {0x00000406, "dk"},
639 {0x00000407, "de"},
640 {0x00000409, "us"},
641 {0x0000040c, "fr"},
642 {0x00000410, "it"},
643 {0x00000813, "be"},
644 {0x00000000, 0},
645};
646
647/* taken from 2.2.7.1.6 Input Capability Set (TS_INPUT_CAPABILITYSET) */
648static char *rdp_keyboard_types[] = {
Hardening4a3c1502013-04-06 23:39:26 +0200649 "", /* 0: unused */
650 "", /* 1: IBM PC/XT or compatible (83-key) keyboard */
651 "", /* 2: Olivetti "ICO" (102-key) keyboard */
652 "", /* 3: IBM PC/AT (84-key) or similar keyboard */
Hardeninga83409c2013-04-01 23:43:58 +0200653 "pc102",/* 4: IBM enhanced (101- or 102-key) keyboard */
Hardening4a3c1502013-04-06 23:39:26 +0200654 "", /* 5: Nokia 1050 and similar keyboards */
655 "", /* 6: Nokia 9140 and similar keyboards */
656 "" /* 7: Japanese keyboard */
Hardeninga83409c2013-04-01 23:43:58 +0200657};
658
659static BOOL
660xf_peer_post_connect(freerdp_peer* client)
661{
662 RdpPeerContext *peerCtx;
663 struct rdp_compositor *c;
664 struct rdp_output *output;
665 rdpSettings *settings;
Hardeningc39118b2013-05-22 23:40:19 +0200666 rdpPointerUpdate *pointer;
Hardeninga83409c2013-04-01 23:43:58 +0200667 struct xkb_context *xkbContext;
668 struct xkb_rule_names xkbRuleNames;
669 struct xkb_keymap *keymap;
670 int i;
Hardeningc39118b2013-05-22 23:40:19 +0200671 pixman_box32_t box;
672 pixman_region32_t damage;
673
Hardeninga83409c2013-04-01 23:43:58 +0200674
Hardeninga83409c2013-04-01 23:43:58 +0200675 peerCtx = (RdpPeerContext *)client->context;
676 c = peerCtx->rdpCompositor;
677 output = c->output;
678 settings = client->settings;
679
Hardening57388e42013-09-18 23:56:36 +0200680 if (!settings->SurfaceCommandsEnabled) {
Hardeninga83409c2013-04-01 23:43:58 +0200681 weston_log("client doesn't support required SurfaceCommands\n");
682 return FALSE;
683 }
684
Hardening57388e42013-09-18 23:56:36 +0200685 if (output->base.width != (int)settings->DesktopWidth ||
Hardeninga83409c2013-04-01 23:43:58 +0200686 output->base.height != (int)settings->DesktopHeight)
687 {
Hardening57388e42013-09-18 23:56:36 +0200688 struct weston_mode new_mode;
689 struct weston_mode *target_mode;
690 new_mode.width = (int)settings->DesktopWidth;
691 new_mode.height = (int)settings->DesktopHeight;
692 target_mode = find_matching_mode(&output->base, &new_mode);
693 if (!target_mode) {
694 weston_log("client mode not found\n");
Hardeninga83409c2013-04-01 23:43:58 +0200695 return FALSE;
696 }
Hardening57388e42013-09-18 23:56:36 +0200697 weston_output_switch_mode(&output->base, target_mode, 1, WESTON_MODE_SWITCH_SET_NATIVE);
698 output->base.width = new_mode.width;
699 output->base.height = new_mode.height;
Hardeninga83409c2013-04-01 23:43:58 +0200700 }
701
702 weston_log("kbd_layout:%x kbd_type:%x kbd_subType:%x kbd_functionKeys:%x\n",
703 settings->KeyboardLayout, settings->KeyboardType, settings->KeyboardSubType,
704 settings->KeyboardFunctionKey);
705
706 memset(&xkbRuleNames, 0, sizeof(xkbRuleNames));
707 if(settings->KeyboardType <= 7)
708 xkbRuleNames.model = rdp_keyboard_types[settings->KeyboardType];
709 for(i = 0; rdp_keyboards[i].xkbLayout; i++) {
710 if(rdp_keyboards[i].rdpLayoutCode == settings->KeyboardLayout) {
711 xkbRuleNames.layout = rdp_keyboards[i].xkbLayout;
712 break;
713 }
714 }
715
716 keymap = NULL;
717 if(xkbRuleNames.layout) {
718 xkbContext = xkb_context_new(0);
719 if(!xkbContext) {
720 weston_log("unable to create a xkb_context\n");
721 return FALSE;
722 }
723
724 keymap = xkb_keymap_new_from_names(xkbContext, &xkbRuleNames, 0);
725 }
726 weston_seat_init_keyboard(&peerCtx->item.seat, keymap);
727 weston_seat_init_pointer(&peerCtx->item.seat);
728
729 peerCtx->item.flags |= RDP_PEER_ACTIVATED;
Hardeningc39118b2013-05-22 23:40:19 +0200730
731 /* disable pointer on the client side */
732 pointer = client->update->pointer;
733 pointer->pointer_system.type = SYSPTR_NULL;
734 pointer->PointerSystem(client->context, &pointer->pointer_system);
735
736 /* sends a full refresh */
737 box.x1 = 0;
738 box.y1 = 0;
739 box.x2 = output->base.width;
740 box.y2 = output->base.height;
741 pixman_region32_init_with_extents(&damage, &box);
742
743 rdp_peer_refresh_region(&damage, client);
744
745 pixman_region32_fini(&damage);
746
Hardeninga83409c2013-04-01 23:43:58 +0200747 return TRUE;
748}
749
750static BOOL
751xf_peer_activate(freerdp_peer *client)
752{
Hardening827358e2013-05-22 23:40:18 +0200753 RdpPeerContext *context = (RdpPeerContext *)client->context;
754 rfx_context_reset(context->rfx_context);
Hardeninga83409c2013-04-01 23:43:58 +0200755 return TRUE;
756}
757
758static void
759xf_mouseEvent(rdpInput *input, UINT16 flags, UINT16 x, UINT16 y) {
Hardeningb60e46f2013-06-03 22:55:47 +0200760 wl_fixed_t wl_x, wl_y, axis;
Hardeninga83409c2013-04-01 23:43:58 +0200761 RdpPeerContext *peerContext = (RdpPeerContext *)input->context;
762 struct rdp_output *output;
763 uint32_t button = 0;
764
765 if (flags & PTR_FLAGS_MOVE) {
766 output = peerContext->rdpCompositor->output;
767 if(x < output->base.width && y < output->base.height) {
768 wl_x = wl_fixed_from_int((int)x);
769 wl_y = wl_fixed_from_int((int)y);
770 notify_motion_absolute(&peerContext->item.seat, weston_compositor_get_time(),
771 wl_x, wl_y);
772 }
773 }
774
775 if (flags & PTR_FLAGS_BUTTON1)
776 button = BTN_LEFT;
777 else if (flags & PTR_FLAGS_BUTTON2)
778 button = BTN_RIGHT;
779 else if (flags & PTR_FLAGS_BUTTON3)
780 button = BTN_MIDDLE;
781
782 if(button) {
783 notify_button(&peerContext->item.seat, weston_compositor_get_time(), button,
784 (flags & PTR_FLAGS_DOWN) ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED
785 );
786 }
Hardeningb60e46f2013-06-03 22:55:47 +0200787
788 if (flags & PTR_FLAGS_WHEEL) {
789 /* DEFAULT_AXIS_STEP_DISTANCE is stolen from compositor-x11.c
790 * The RDP specs says the lower bits of flags contains the "the number of rotation
791 * units the mouse wheel was rotated".
792 *
793 * http://blogs.msdn.com/b/oldnewthing/archive/2013/01/23/10387366.aspx explains the 120 value
794 */
795 axis = (DEFAULT_AXIS_STEP_DISTANCE * (flags & 0xff)) / 120;
796 if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
797 axis = -axis;
798
799 notify_axis(&peerContext->item.seat, weston_compositor_get_time(),
800 WL_POINTER_AXIS_VERTICAL_SCROLL,
801 axis);
802 }
Hardeninga83409c2013-04-01 23:43:58 +0200803}
804
805static void
806xf_extendedMouseEvent(rdpInput *input, UINT16 flags, UINT16 x, UINT16 y) {
807 wl_fixed_t wl_x, wl_y;
808 RdpPeerContext *peerContext = (RdpPeerContext *)input->context;
809 struct rdp_output *output;
810
811 output = peerContext->rdpCompositor->output;
812 if(x < output->base.width && y < output->base.height) {
813 wl_x = wl_fixed_from_int((int)x);
814 wl_y = wl_fixed_from_int((int)y);
815 notify_motion_absolute(&peerContext->item.seat, weston_compositor_get_time(),
816 wl_x, wl_y);
817 }
818}
819
820
821static void
822xf_input_synchronize_event(rdpInput *input, UINT32 flags)
823{
824 freerdp_peer *client = input->context->peer;
Hardeninga83409c2013-04-01 23:43:58 +0200825 RdpPeerContext *peerCtx = (RdpPeerContext *)input->context;
826 struct rdp_output *output = peerCtx->rdpCompositor->output;
827 pixman_box32_t box;
828 pixman_region32_t damage;
829
Hardeninga83409c2013-04-01 23:43:58 +0200830 /* sends a full refresh */
831 box.x1 = 0;
832 box.y1 = 0;
833 box.x2 = output->base.width;
834 box.y2 = output->base.height;
835 pixman_region32_init_with_extents(&damage, &box);
836
837 rdp_peer_refresh_region(&damage, client);
838
839 pixman_region32_fini(&damage);
840}
841
Hardening4a3c1502013-04-06 23:39:26 +0200842extern DWORD KEYCODE_TO_VKCODE_EVDEV[];
843static uint32_t vk_to_keycode[256];
844static void
845init_vk_translator(void)
846{
847 int i;
848
849 memset(vk_to_keycode, 0, sizeof(vk_to_keycode));
850 for(i = 0; i < 256; i++)
851 vk_to_keycode[KEYCODE_TO_VKCODE_EVDEV[i] & 0xff] = i-8;
852}
853
Hardeninga83409c2013-04-01 23:43:58 +0200854static void
855xf_input_keyboard_event(rdpInput *input, UINT16 flags, UINT16 code)
856{
Hardening4a3c1502013-04-06 23:39:26 +0200857 uint32_t scan_code, vk_code, full_code;
Hardeninga83409c2013-04-01 23:43:58 +0200858 enum wl_keyboard_key_state keyState;
859 RdpPeerContext *peerContext = (RdpPeerContext *)input->context;
860 int notify = 0;
861
862 if (flags & KBD_FLAGS_DOWN) {
863 keyState = WL_KEYBOARD_KEY_STATE_PRESSED;
864 notify = 1;
865 } else if (flags & KBD_FLAGS_RELEASE) {
866 keyState = WL_KEYBOARD_KEY_STATE_RELEASED;
867 notify = 1;
868 }
869
Hardening4a3c1502013-04-06 23:39:26 +0200870 if(notify) {
871 full_code = code;
872 if(flags & KBD_FLAGS_EXTENDED)
873 full_code |= KBD_FLAGS_EXTENDED;
874
875 vk_code = GetVirtualKeyCodeFromVirtualScanCode(full_code, 4);
876 if(vk_code > 0xff) {
877 weston_log("invalid vk_code %x", vk_code);
878 return;
879 }
880 scan_code = vk_to_keycode[vk_code];
881
882
883 /*weston_log("code=%x ext=%d vk_code=%x scan_code=%x\n", code, (flags & KBD_FLAGS_EXTENDED) ? 1 : 0,
884 vk_code, scan_code);*/
Hardeninga83409c2013-04-01 23:43:58 +0200885 notify_key(&peerContext->item.seat, weston_compositor_get_time(),
Hardening4a3c1502013-04-06 23:39:26 +0200886 scan_code, keyState, STATE_UPDATE_AUTOMATIC);
887 }
Hardeninga83409c2013-04-01 23:43:58 +0200888}
889
890static void
891xf_input_unicode_keyboard_event(rdpInput *input, UINT16 flags, UINT16 code)
892{
893 weston_log("Client sent a unicode keyboard event (flags:0x%X code:0x%X)\n", flags, code);
894}
895
896
897static void
898xf_suppress_output(rdpContext *context, BYTE allow, RECTANGLE_16 *area) {
899 RdpPeerContext *peerContext = (RdpPeerContext *)context;
900 if(allow)
901 peerContext->item.flags |= RDP_PEER_OUTPUT_ENABLED;
902 else
903 peerContext->item.flags &= (~RDP_PEER_OUTPUT_ENABLED);
904}
905
906static int
907rdp_peer_init(freerdp_peer *client, struct rdp_compositor *c)
908{
909 int rcount = 0;
910 void *rfds[MAX_FREERDP_FDS];
911 int i, fd;
912 struct wl_event_loop *loop;
913 rdpSettings *settings;
914 rdpInput *input;
915 RdpPeerContext *peerCtx;
Rob Bradford9af5f9e2013-05-31 18:09:50 +0100916 char seat_name[32];
Hardeninga83409c2013-04-01 23:43:58 +0200917
Hardeningfe107f32013-07-08 00:51:34 +0200918 client->ContextSize = sizeof(RdpPeerContext);
Hardeninga83409c2013-04-01 23:43:58 +0200919 client->ContextNew = (psPeerContextNew)rdp_peer_context_new;
920 client->ContextFree = (psPeerContextFree)rdp_peer_context_free;
921 freerdp_peer_context_new(client);
922
923 peerCtx = (RdpPeerContext *) client->context;
924 peerCtx->rdpCompositor = c;
925
926 settings = client->settings;
927 settings->RdpKeyFile = c->rdp_key;
928 if(c->tls_enabled) {
929 settings->CertificateFile = c->server_cert;
930 settings->PrivateKeyFile = c->server_key;
931 } else {
932 settings->TlsSecurity = FALSE;
933 }
934
935 settings->NlaSecurity = FALSE;
936
937 client->Capabilities = xf_peer_capabilities;
938 client->PostConnect = xf_peer_post_connect;
939 client->Activate = xf_peer_activate;
940
941 client->update->SuppressOutput = xf_suppress_output;
942
943 input = client->input;
944 input->SynchronizeEvent = xf_input_synchronize_event;
945 input->MouseEvent = xf_mouseEvent;
946 input->ExtendedMouseEvent = xf_extendedMouseEvent;
947 input->KeyboardEvent = xf_input_keyboard_event;
948 input->UnicodeKeyboardEvent = xf_input_unicode_keyboard_event;
Rob Bradford9af5f9e2013-05-31 18:09:50 +0100949
950 if (snprintf(seat_name, 32, "rdp:%d:%s", client->sockfd, client->hostname) >= 32)
951 seat_name[31] = '\0';
952
953 weston_seat_init(&peerCtx->item.seat, &c->base, seat_name);
Hardeninga83409c2013-04-01 23:43:58 +0200954
955 client->Initialize(client);
956
957 if (!client->GetFileDescriptor(client, rfds, &rcount)) {
958 weston_log("unable to retrieve client fds\n");
959 return -1;
960 }
961
962 loop = wl_display_get_event_loop(c->base.wl_display);
963 for(i = 0; i < rcount; i++) {
964 fd = (int)(long)(rfds[i]);
965
Hardeninga83409c2013-04-01 23:43:58 +0200966 peerCtx->events[i] = wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
967 rdp_client_activity, client);
968 }
Hardeningb8f03aa2013-05-26 23:34:00 +0200969 for ( ; i < MAX_FREERDP_FDS; i++)
Hardeninga83409c2013-04-01 23:43:58 +0200970 peerCtx->events[i] = 0;
Hardeninga83409c2013-04-01 23:43:58 +0200971
972 wl_list_insert(&c->output->peers, &peerCtx->item.link);
973 return 0;
974}
975
976
977static void
978rdp_incoming_peer(freerdp_listener *instance, freerdp_peer *client)
979{
980 struct rdp_compositor *c = (struct rdp_compositor *)instance->param4;
981 if (rdp_peer_init(client, c) < 0)
982 return;
983}
984
985static struct weston_compositor *
986rdp_compositor_create(struct wl_display *display,
987 struct rdp_compositor_config *config,
Hardening6a4e8c62013-05-27 23:13:45 +0200988 int *argc, char *argv[], struct weston_config *wconfig)
Hardeninga83409c2013-04-01 23:43:58 +0200989{
990 struct rdp_compositor *c;
991 char *fd_str;
992 int fd;
993
Peter Huttererf3d62272013-08-08 11:57:05 +1000994 c = zalloc(sizeof *c);
Hardeninga83409c2013-04-01 23:43:58 +0200995 if (c == NULL)
996 return NULL;
997
Hardening6a4e8c62013-05-27 23:13:45 +0200998 if (weston_compositor_init(&c->base, display, argc, argv, wconfig) < 0)
Hardeninga83409c2013-04-01 23:43:58 +0200999 goto err_free;
1000
Hardeninga83409c2013-04-01 23:43:58 +02001001 c->base.destroy = rdp_destroy;
1002 c->base.restore = rdp_restore;
1003 c->rdp_key = config->rdp_key ? strdup(config->rdp_key) : NULL;
1004
1005 /* activate TLS only if certificate/key are available */
1006 if(config->server_cert && config->server_key) {
1007 weston_log("TLS support activated\n");
1008 c->server_cert = strdup(config->server_cert);
1009 c->server_key = strdup(config->server_key);
1010 if(!c->server_cert || !c->server_key)
1011 goto err_free_strings;
1012 c->tls_enabled = 1;
1013 }
1014
1015 if (pixman_renderer_init(&c->base) < 0)
1016 goto err_compositor;
1017
1018 if (rdp_compositor_create_output(c, config->width, config->height, config->extra_modes) < 0)
1019 goto err_compositor;
1020
1021 if(!config->env_socket) {
1022 c->listener = freerdp_listener_new();
1023 c->listener->PeerAccepted = rdp_incoming_peer;
1024 c->listener->param4 = c;
1025 if(!c->listener->Open(c->listener, config->bind_address, config->port)) {
1026 weston_log("unable to bind rdp socket\n");
1027 goto err_listener;
1028 }
1029
1030 if (rdp_implant_listener(c, c->listener) < 0)
1031 goto err_compositor;
1032 } else {
1033 /* get the socket from RDP_FD var */
1034 fd_str = getenv("RDP_FD");
1035 if(!fd_str) {
1036 weston_log("RDP_FD env variable not set");
1037 goto err_output;
1038 }
1039
1040 fd = strtoul(fd_str, NULL, 10);
1041 if(rdp_peer_init(freerdp_peer_new(fd), c))
1042 goto err_output;
1043 }
1044
1045 return &c->base;
1046
1047err_listener:
1048 freerdp_listener_free(c->listener);
1049err_output:
1050 weston_output_destroy(&c->output->base);
1051err_compositor:
1052 weston_compositor_shutdown(&c->base);
1053err_free_strings:
1054 if(c->rdp_key)
1055 free(c->rdp_key);
1056 if(c->server_cert)
1057 free(c->server_cert);
1058 if(c->server_key)
1059 free(c->server_key);
Hardeninga83409c2013-04-01 23:43:58 +02001060err_free:
1061 free(c);
1062 return NULL;
1063}
1064
1065WL_EXPORT struct weston_compositor *
1066backend_init(struct wl_display *display, int *argc, char *argv[],
Hardening6a4e8c62013-05-27 23:13:45 +02001067 struct weston_config *wconfig)
Hardeninga83409c2013-04-01 23:43:58 +02001068{
1069 struct rdp_compositor_config config;
1070 rdp_compositor_config_init(&config);
1071 int major, minor, revision;
1072
1073 freerdp_get_version(&major, &minor, &revision);
1074 weston_log("using FreeRDP version %d.%d.%d\n", major, minor, revision);
Hardening4a3c1502013-04-06 23:39:26 +02001075 init_vk_translator();
Hardeninga83409c2013-04-01 23:43:58 +02001076
1077 const struct weston_option rdp_options[] = {
1078 { WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket },
1079 { WESTON_OPTION_INTEGER, "width", 0, &config.width },
1080 { WESTON_OPTION_INTEGER, "height", 0, &config.height },
1081 { WESTON_OPTION_STRING, "extra-modes", 0, &config.extra_modes },
1082 { WESTON_OPTION_STRING, "address", 0, &config.bind_address },
1083 { WESTON_OPTION_INTEGER, "port", 0, &config.port },
1084 { WESTON_OPTION_STRING, "rdp4-key", 0, &config.rdp_key },
1085 { WESTON_OPTION_STRING, "rdp-tls-cert", 0, &config.server_cert },
1086 { WESTON_OPTION_STRING, "rdp-tls-key", 0, &config.server_key }
1087 };
1088
1089 parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv);
Hardening6a4e8c62013-05-27 23:13:45 +02001090 return rdp_compositor_create(display, &config, argc, argv, wconfig);
Hardeninga83409c2013-04-01 23:43:58 +02001091}