cunit/test_cliprdr.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * Clipboard Virtual Channel Unit Tests
   4  *
   5  * Copyright 2011 Vic Lee
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <freerdp/freerdp.h>
  24 #include <freerdp/constants.h>
  25 #include <freerdp/channels/channels.h>
  26 #include <freerdp/utils/event.h>
  27 #include <freerdp/utils/hexdump.h>
  28 #include <freerdp/utils/memory.h>
  29 #include <freerdp/plugins/cliprdr.h>
  30
  31 #include "test_cliprdr.h"
  32
  33 int init_cliprdr_suite(void)
  34 {
  35         freerdp_channels_global_init();
  36         return 0;
  37 }
  38
  39 int clean_cliprdr_suite(void)
  40 {
  41         freerdp_channels_global_uninit();
  42         return 0;
  43 }
  44
  45 int add_cliprdr_suite(void)
  46 {
  47         add_test_suite(cliprdr);
  48
  49         add_test_function(cliprdr);
  50
  51         return 0;
  52 }
  53
  54 static const uint8 test_clip_caps_data[] =
  55 {
  56         "\x07\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x01\x00\x0C\x00"
  57         "\x02\x00\x00\x00\x0E\x00\x00\x00"
  58 };
  59
  60 static const uint8 test_monitor_ready_data[] =
  61 {
  62         "\x01\x00\x00\x00\x00\x00\x00\x00"
  63 };
  64
  65 static const uint8 test_format_list_data[] =
  66 {
  67         "\x02\x00\x00\x00\x48\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
  68         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  69         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\xd0\x00\x00"
  70         "\x48\x00\x54\x00\x4D\x00\x4C\x00\x20\x00\x46\x00\x6F\x00\x72\x00"
  71         "\x6D\x00\x61\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  72 };
  73
  74 static const uint8 test_format_list_response_data[] =
  75 {
  76         "\x03\x00\x01\x00\x00\x00\x00\x00"
  77 };
  78
  79 static const uint8 test_data_request_data[] =
  80 {
  81         "\x04\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00"
  82 };
  83
  84 static const uint8 test_data_response_data[] =
  85 {
  86         "\x05\x00\x01\x00\x18\x00\x00\x00\x68\x00\x65\x00\x6C\x00\x6C\x00"
  87         "\x6F\x00\x20\x00\x77\x00\x6F\x00\x72\x00\x6c\x00\x64\x00\x00\x00"
  88 };
  89
  90 static int test_rdp_channel_data(freerdp* instance, int chan_id, uint8* data, int data_size)
  91 {
  92         printf("chan_id %d data_size %d\n", chan_id, data_size);
  93         freerdp_hexdump(data, data_size);
  94         return 0;
  95 }
  96
  97 static int event_processed;
  98
  99 static void event_process_callback(RDP_EVENT* event)
 100 {
 101         printf("Event %d processed.\n", event->event_type);
 102         event_processed = 1;
 103 }
 104
 105 void test_cliprdr(void)
 106 {
 107         int i;
 108         rdpChannels* channels;
 109         rdpSettings settings = { 0 };
 110         freerdp instance = { 0 };
 111         RDP_EVENT* event;
 112         RDP_CB_FORMAT_LIST_EVENT* format_list_event;
 113         RDP_CB_DATA_REQUEST_EVENT* data_request_event;
 114         RDP_CB_DATA_RESPONSE_EVENT* data_response_event;
 115
 116         settings.hostname = "testhost";
 117         instance.settings = &settings;
 118         instance.SendChannelData = test_rdp_channel_data;
 119
 120         channels = freerdp_channels_new();
 121
 122         freerdp_channels_load_plugin(channels, &settings, "../channels/cliprdr/cliprdr.so", NULL);
 123         freerdp_channels_pre_connect(channels, &instance);
 124         freerdp_channels_post_connect(channels, &instance);
 125
 126         /* server sends cliprdr capabilities and monitor ready PDU */
 127         freerdp_channels_data(&instance, 0, (char*)test_clip_caps_data, sizeof(test_clip_caps_data) - 1,
 128                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_clip_caps_data) - 1);
 129
 130         freerdp_channels_data(&instance, 0, (char*)test_monitor_ready_data, sizeof(test_monitor_ready_data) - 1,
 131                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_monitor_ready_data) - 1);
 132
 133         /* cliprdr sends clipboard_sync event to UI */
 134         while ((event = freerdp_channels_pop_event(channels)) == NULL)
 135         {
 136                 freerdp_channels_check_fds(channels, &instance);
 137         }
 138         printf("Got event %d\n", event->event_type);
 139         CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_MONITOR_READY);
 140         freerdp_event_free(event);
 141
 142         /* UI sends format_list event to cliprdr */
 143         event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_FORMAT_LIST, event_process_callback, NULL);
 144         format_list_event = (RDP_CB_FORMAT_LIST_EVENT*) event;
 145         format_list_event->num_formats = 2;
 146         format_list_event->formats = (uint32*) xmalloc(sizeof(uint32) * 2);
 147         format_list_event->formats[0] = CB_FORMAT_TEXT;
 148         format_list_event->formats[1] = CB_FORMAT_HTML;
 149         event_processed = 0;
 150         freerdp_channels_send_event(channels, event);
 151
 152         /* cliprdr sends format list PDU to server */
 153         while (!event_processed)
 154         {
 155                 freerdp_channels_check_fds(channels, &instance);
 156         }
 157
 158         /* server sends format list response PDU to cliprdr */
 159         freerdp_channels_data(&instance, 0, (char*)test_format_list_response_data, sizeof(test_format_list_response_data) - 1,
 160                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_format_list_response_data) - 1);
 161
 162         /* server sends format list PDU to cliprdr */
 163         freerdp_channels_data(&instance, 0, (char*)test_format_list_data, sizeof(test_format_list_data) - 1,
 164                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_format_list_data) - 1);
 165
 166         /* cliprdr sends format_list event to UI */
 167         while ((event = freerdp_channels_pop_event(channels)) == NULL)
 168         {
 169                 freerdp_channels_check_fds(channels, &instance);
 170         }
 171         printf("Got event %d\n", event->event_type);
 172         CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_FORMAT_LIST);
 173         if (event->event_type == RDP_EVENT_TYPE_CB_FORMAT_LIST)
 174         {
 175                 format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event;
 176                 for (i = 0; i < format_list_event->num_formats; i++)
 177                         printf("Format: 0x%X\n", format_list_event->formats[i]);
 178         }
 179         freerdp_event_free(event);
 180
 181         /* server sends data request PDU to cliprdr */
 182         freerdp_channels_data(&instance, 0, (char*)test_data_request_data, sizeof(test_data_request_data) - 1,
 183                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_data_request_data) - 1);
 184
 185         /* cliprdr sends data request event to UI */
 186         while ((event = freerdp_channels_pop_event(channels)) == NULL)
 187         {
 188                 freerdp_channels_check_fds(channels, &instance);
 189         }
 190         printf("Got event %d\n", event->event_type);
 191         CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_DATA_REQUEST);
 192         if (event->event_type == RDP_EVENT_TYPE_CB_DATA_REQUEST)
 193         {
 194                 data_request_event = (RDP_CB_DATA_REQUEST_EVENT*)event;
 195                 printf("Requested format: 0x%X\n", data_request_event->format);
 196         }
 197         freerdp_event_free(event);
 198
 199         /* UI sends data response event to cliprdr */
 200         event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_DATA_RESPONSE, event_process_callback, NULL);
 201         data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
 202         data_response_event->data = (uint8*)xmalloc(6);
 203         strcpy((char*)data_response_event->data, "hello");
 204         data_response_event->size = 6;
 205         event_processed = 0;
 206         freerdp_channels_send_event(channels, event);
 207
 208         /* cliprdr sends data response PDU to server */
 209         while (!event_processed)
 210         {
 211                 freerdp_channels_check_fds(channels, &instance);
 212         }
 213
 214         /* UI sends data request event to cliprdr */
 215         event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_DATA_REQUEST, event_process_callback, NULL);
 216         data_request_event = (RDP_CB_DATA_REQUEST_EVENT*)event;
 217         data_request_event->format = CB_FORMAT_UNICODETEXT;
 218         event_processed = 0;
 219         freerdp_channels_send_event(channels, event);
 220
 221         /* cliprdr sends data request PDU to server */
 222         while (!event_processed)
 223         {
 224                 freerdp_channels_check_fds(channels, &instance);
 225         }
 226
 227         /* server sends data response PDU to cliprdr */
 228         freerdp_channels_data(&instance, 0, (char*)test_data_response_data, sizeof(test_data_response_data) - 1,
 229                 CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_data_response_data) - 1);
 230
 231         /* cliprdr sends data response event to UI */
 232         while ((event = freerdp_channels_pop_event(channels)) == NULL)
 233         {
 234                 freerdp_channels_check_fds(channels, &instance);
 235         }
 236         printf("Got event %d\n", event->event_type);
 237         CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_DATA_RESPONSE);
 238         if (event->event_type == RDP_EVENT_TYPE_CB_DATA_RESPONSE)
 239         {
 240                 data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
 241                 printf("Data response size: %d\n", data_response_event->size);
 242                 freerdp_hexdump(data_response_event->data, data_response_event->size);
 243         }
 244         freerdp_event_free(event);
 245
 246         freerdp_channels_close(channels, &instance);
 247         freerdp_channels_free(channels);
 248 }