/** * FreeRDP: A Remote Desktop Protocol Implementation * FreeRDP Test UI * * Copyright 2011 Marc-Andre Moreau * Copyright 2016,2018 Armin Novak * Copyright 2016,2018 Thincast Technologies GmbH * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "tf_channels.h" #include "tf_freerdp.h" #define TAG CLIENT_TAG("sample") /* This function is called whenever a new frame starts. * It can be used to reset invalidated areas. */ static BOOL tf_begin_paint(rdpContext* context) { rdpGdi* gdi = context->gdi; gdi->primary->hdc->hwnd->invalid->null = TRUE; return TRUE; } /* This function is called when the library completed composing a new * frame. Read out the changed areas and blit them to your output device. * The image buffer will have the format specified by gdi_init */ static BOOL tf_end_paint(rdpContext* context) { rdpGdi* gdi = context->gdi; if (gdi->primary->hdc->hwnd->invalid->null) return TRUE; return TRUE; } /* This function is called to output a System BEEP */ static BOOL tf_play_sound(rdpContext* context, const PLAY_SOUND_UPDATE* play_sound) { /* TODO: Implement */ WINPR_UNUSED(context); WINPR_UNUSED(play_sound); return TRUE; } /* This function is called to update the keyboard indocator LED */ static BOOL tf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags) { /* TODO: Set local keyboard indicator LED status */ WINPR_UNUSED(context); WINPR_UNUSED(led_flags); return TRUE; } /* This function is called to set the IME state */ static BOOL tf_keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState, UINT32 imeConvMode) { if (!context) return FALSE; WLog_WARN(TAG, "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32 ", imeConvMode=%08" PRIx32 ") ignored", imeId, imeState, imeConvMode); return TRUE; } /* Called before a connection is established. * Set all configuration options to support and load channels here. */ static BOOL tf_pre_connect(freerdp* instance) { rdpSettings* settings; settings = instance->settings; /* Optional OS identifier sent to server */ settings->OsMajorType = OSMAJORTYPE_UNIX; settings->OsMinorType = OSMINORTYPE_NATIVE_XSERVER; /* settings->OrderSupport is initialized at this point. * Only override it if you plan to implement custom order * callbacks or deactiveate certain features. */ /* Register the channel listeners. * They are required to set up / tear down channels if they are loaded. */ PubSub_SubscribeChannelConnected(instance->context->pubSub, tf_OnChannelConnectedEventHandler); PubSub_SubscribeChannelDisconnected(instance->context->pubSub, tf_OnChannelDisconnectedEventHandler); /* Load all required plugins / channels / libraries specified by current * settings. */ if (!freerdp_client_load_addins(instance->context->channels, instance->settings)) return FALSE; /* TODO: Any code your client requires */ return TRUE; } /* Called after a RDP connection was successfully established. * Settings might have changed during negociation of client / server feature * support. * * Set up local framebuffers and paing callbacks. * If required, register pointer callbacks to change the local mouse cursor * when hovering over the RDP window */ static BOOL tf_post_connect(freerdp* instance) { if (!gdi_init(instance, PIXEL_FORMAT_XRGB32)) return FALSE; instance->update->BeginPaint = tf_begin_paint; instance->update->EndPaint = tf_end_paint; instance->update->PlaySound = tf_play_sound; instance->update->SetKeyboardIndicators = tf_keyboard_set_indicators; instance->update->SetKeyboardImeStatus = tf_keyboard_set_ime_status; return TRUE; } /* This function is called whether a session ends by failure or success. * Clean up everything allocated by pre_connect and post_connect. */ static void tf_post_disconnect(freerdp* instance) { tfContext* context; if (!instance) return; if (!instance->context) return; context = (tfContext*)instance->context; PubSub_UnsubscribeChannelConnected(instance->context->pubSub, tf_OnChannelConnectedEventHandler); PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub, tf_OnChannelDisconnectedEventHandler); gdi_free(instance); /* TODO : Clean up custom stuff */ WINPR_UNUSED(context); } /* RDP main loop. * Connects RDP, loops while running and handles event and dispatch, cleans up * after the connection ends. */ static DWORD WINAPI tf_client_thread_proc(LPVOID arg) { freerdp* instance = (freerdp*)arg; DWORD nCount; DWORD status; DWORD result = 0; HANDLE handles[64]; BOOL rc = freerdp_connect(instance); if (instance->settings->AuthenticationOnly) { result = freerdp_get_last_error(instance->context); freerdp_abort_connect(instance); WLog_ERR(TAG, "Authentication only, exit status 0x%08" PRIx32 "", result); goto disconnect; } if (!rc) { result = freerdp_get_last_error(instance->context); WLog_ERR(TAG, "connection failure 0x%08" PRIx32, result); return result; } while (!freerdp_shall_disconnect(instance)) { nCount = freerdp_get_event_handles(instance->context, &handles[0], 64); if (nCount == 0) { WLog_ERR(TAG, "%s: freerdp_get_event_handles failed", __FUNCTION__); break; } status = WaitForMultipleObjects(nCount, handles, FALSE, 100); if (status == WAIT_FAILED) { WLog_ERR(TAG, "%s: WaitForMultipleObjects failed with %" PRIu32 "", __FUNCTION__, status); break; } if (!freerdp_check_event_handles(instance->context)) { if (freerdp_get_last_error(instance->context) == FREERDP_ERROR_SUCCESS) WLog_ERR(TAG, "Failed to check FreeRDP event handles"); break; } } disconnect: freerdp_disconnect(instance); return result; } /* Optional global initializer. * Here we just register a signal handler to print out stack traces * if available. */ static BOOL tf_client_global_init(void) { if (freerdp_handle_signals() != 0) return FALSE; return TRUE; } /* Optional global tear down */ static void tf_client_global_uninit(void) { } static int tf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type) { tfContext* tf; const char* str_data = freerdp_get_logon_error_info_data(data); const char* str_type = freerdp_get_logon_error_info_type(type); if (!instance || !instance->context) return -1; tf = (tfContext*)instance->context; WLog_INFO(TAG, "Logon Error Info %s [%s]", str_data, str_type); WINPR_UNUSED(tf); return 1; } static BOOL tf_client_new(freerdp* instance, rdpContext* context) { tfContext* tf = (tfContext*)context; if (!instance || !context) return FALSE; instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->PostDisconnect = tf_post_disconnect; instance->Authenticate = client_cli_authenticate; instance->GatewayAuthenticate = client_cli_gw_authenticate; instance->VerifyCertificateEx = client_cli_verify_certificate_ex; instance->VerifyChangedCertificateEx = client_cli_verify_changed_certificate_ex; instance->LogonErrorInfo = tf_logon_error_info; /* TODO: Client display set up */ WINPR_UNUSED(tf); return TRUE; } static void tf_client_free(freerdp* instance, rdpContext* context) { tfContext* tf = (tfContext*)instance->context; if (!context) return; /* TODO: Client display tear down */ WINPR_UNUSED(tf); } static int tf_client_start(rdpContext* context) { /* TODO: Start client related stuff */ WINPR_UNUSED(context); return 0; } static int tf_client_stop(rdpContext* context) { /* TODO: Stop client related stuff */ WINPR_UNUSED(context); return 0; } static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints) { ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS)); pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION; pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1); pEntryPoints->GlobalInit = tf_client_global_init; pEntryPoints->GlobalUninit = tf_client_global_uninit; pEntryPoints->ContextSize = sizeof(tfContext); pEntryPoints->ClientNew = tf_client_new; pEntryPoints->ClientFree = tf_client_free; pEntryPoints->ClientStart = tf_client_start; pEntryPoints->ClientStop = tf_client_stop; return 0; } int main(int argc, char* argv[]) { int rc = -1; DWORD status; RDP_CLIENT_ENTRY_POINTS clientEntryPoints; rdpContext* context; RdpClientEntry(&clientEntryPoints); context = freerdp_client_context_new(&clientEntryPoints); if (!context) goto fail; status = freerdp_client_settings_parse_command_line(context->settings, argc, argv, FALSE); status = freerdp_client_settings_command_line_status_print(context->settings, status, argc, argv); if (status) { rc = 0; goto fail; } if (freerdp_client_start(context) != 0) goto fail; rc = tf_client_thread_proc(context->instance); if (freerdp_client_stop(context) != 0) rc = -1; fail: freerdp_client_context_free(context); return rc; }