int main(int argc, char* argv[]) { int rc = -1; DWORD status; RDP_CLIENT_ENTRY_POINTS clientEntryPoints; rdpContext* context; //if (!handle_uwac_events(NULL, g_display)) // exit(1); 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) return 0; if (freerdp_client_start(context) != 0) goto fail; rc = wlfreerdp_run(context->instance); if (freerdp_client_stop(context) != 0) rc = -1; fail: freerdp_client_context_free(context); return rc; }
static jboolean JNICALL jni_freerdp_parse_arguments( JNIEnv* env, jclass cls, jint instance, jobjectArray arguments) { freerdp* inst = (freerdp*)instance; int i, count; char** argv; DWORD status; if (!inst || !inst->context) return JNI_FALSE; count = (*env)->GetArrayLength(env, arguments); argv = calloc(count, sizeof(char*)); if (!argv) return JNI_TRUE; for (i = 0; i < count; i++) { jstring str = (jstring)(*env)->GetObjectArrayElement(env, arguments, i); const char* raw = (*env)->GetStringUTFChars(env, str, 0); argv[i] = _strdup(raw); (*env)->ReleaseStringUTFChars(env, str, raw); } status = freerdp_client_settings_parse_command_line(inst->settings, count, argv, FALSE); for (i = 0; i < count; i++) free(argv[i]); free(argv); return (status == 0) ? JNI_TRUE : JNI_FALSE; }
int main(int argc, char* argv[]) { int status; HANDLE thread; freerdp* instance; rdpChannels* channels; instance = freerdp_new(); instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->ContextSize = sizeof(tfContext); instance->ContextNew = tf_context_new; instance->ContextFree = tf_context_free; freerdp_context_new(instance); channels = instance->context->channels; status = freerdp_client_settings_parse_command_line(instance->settings, argc, argv); if (status < 0) { exit(0); } freerdp_client_load_addins(instance->context->channels, instance->settings); thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) tf_client_thread_proc, instance, 0, NULL); WaitForSingleObject(thread, INFINITE); return 0; }
int main(int argc, char* argv[]) { int status; pthread_t thread; freerdp* instance; dfContext* context; rdpChannels* channels; struct thread_data* data; setlocale(LC_ALL, ""); g_sem = CreateSemaphore(NULL, 0, 1, NULL); instance = freerdp_new(); instance->PreConnect = df_pre_connect; instance->PostConnect = df_post_connect; instance->VerifyCertificate = df_verify_certificate; instance->ReceiveChannelData = df_receive_channel_data; instance->ContextSize = sizeof(dfContext); instance->ContextNew = df_context_new; instance->ContextFree = df_context_free; freerdp_context_new(instance); context = (dfContext*) instance->context; channels = instance->context->channels; DirectFBInit(&argc, &argv); instance->context->argc = argc; instance->context->argv = argv; status = freerdp_client_settings_parse_command_line(instance->settings, argc, argv); if (status < 0) exit(0); freerdp_client_load_addins(instance->context->channels, instance->settings); data = (struct thread_data*) malloc(sizeof(struct thread_data)); ZeroMemory(data, sizeof(sizeof(struct thread_data))); data->instance = instance; g_thread_count++; pthread_create(&thread, 0, thread_func, data); while (g_thread_count > 0) { WaitForSingleObject(g_sem, INFINITE); } return 0; }
int main(int argc, char* argv[]) { int status; HANDLE thread; freerdp* instance; instance = freerdp_new(); if (!instance) { WLog_ERR(TAG, "Couldn't create instance"); return 1; } instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->ContextSize = sizeof(tfContext); instance->ContextNew = tf_context_new; instance->ContextFree = tf_context_free; freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0); if (!freerdp_context_new(instance)) { WLog_ERR(TAG, "Couldn't create context"); return 1; } status = freerdp_client_settings_parse_command_line(instance->settings, argc, argv, FALSE); if (status < 0) { return 0; } if (!freerdp_client_load_addins(instance->context->channels, instance->settings)) return -1; if (!(thread = CreateThread(NULL, 0, tf_client_thread_proc, instance, 0, NULL))) { WLog_ERR(TAG, "Failed to create client thread"); } else { WaitForSingleObject(thread, INFINITE); } freerdp_context_free(instance); freerdp_free(instance); return 0; }
int main(int argc, char* argv[]) { int status; pthread_t thread; freerdp* instance; rdpChannels* channels; struct thread_data* data; freerdp_channels_global_init(); g_sem = CreateSemaphore(NULL, 0, 1, NULL); instance = freerdp_new(); instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->ReceiveChannelData = tf_receive_channel_data; instance->ContextSize = sizeof(tfContext); instance->ContextNew = tf_context_new; instance->ContextFree = tf_context_free; freerdp_context_new(instance); channels = instance->context->channels; status = freerdp_client_settings_parse_command_line(instance->settings, argc, argv); if (status < 0) exit(0); freerdp_client_load_addins(instance->context->channels, instance->settings); data = (struct thread_data*) malloc(sizeof(struct thread_data)); ZeroMemory(data, sizeof(sizeof(struct thread_data))); data->instance = instance; g_thread_count++; pthread_create(&thread, 0, thread_func, data); while (g_thread_count > 0) { WaitForSingleObject(g_sem, INFINITE); } freerdp_channels_global_uninit(); return 0; }
int main(int argc, char* argv[]) { int status; HANDLE thread; xfContext* xfc; DWORD dwExitCode; rdpContext* context; rdpSettings* settings; RDP_CLIENT_ENTRY_POINTS clientEntryPoints; ZeroMemory(&clientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS)); clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS); clientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION; RdpClientEntry(&clientEntryPoints); context = freerdp_client_context_new(&clientEntryPoints); settings = context->settings; xfc = (xfContext*) context; status = freerdp_client_settings_parse_command_line(context->settings, argc, argv); status = freerdp_client_settings_command_line_status_print(settings, status, argc, argv); if (status) { if (settings->ListMonitors) xf_list_monitors(xfc); freerdp_client_context_free(context); return 0; } freerdp_client_start(context); thread = freerdp_client_get_thread(context); WaitForSingleObject(thread, INFINITE); GetExitCodeThread(thread, &dwExitCode); freerdp_client_stop(context); freerdp_client_context_free(context); return xf_exit_code_from_disconnect_reason(dwExitCode); }
static int runInstance(int argc, char* argv[], freerdp** inst) { int rc = -1; freerdp* instance = freerdp_new(); if (!instance) goto finish; if (inst) *inst = instance; if (!freerdp_context_new(instance)) goto finish; if (freerdp_client_settings_parse_command_line(instance->settings, argc, argv, FALSE) < 0) goto finish; if (!freerdp_client_load_addins(instance->context->channels, instance->settings)) goto finish; if (s_sync) { if (!SetEvent(s_sync)) goto finish; } rc = 1; if (!freerdp_connect(instance)) goto finish; rc = 2; if (!freerdp_disconnect(instance)) goto finish; rc = 0; finish: freerdp_context_free(instance); freerdp_free(instance); return rc; }
BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings* settings) { if (~((size_t) file->Domain)) freerdp_set_param_string(settings, FreeRDP_Domain, file->Domain); if (~((size_t) file->Username)) { char* user = NULL; char* domain = NULL; freerdp_parse_username(file->Username, &user, &domain); freerdp_set_param_string(settings, FreeRDP_Username, user); if (domain) freerdp_set_param_string(settings, FreeRDP_Domain, domain); if (user) free(user); if (domain) free(domain); } if (~file->ServerPort) freerdp_set_param_uint32(settings, FreeRDP_ServerPort, file->ServerPort); if (~((size_t) file->FullAddress)) freerdp_set_param_string(settings, FreeRDP_ServerHostname, file->FullAddress); if (~file->DesktopWidth) freerdp_set_param_uint32(settings, FreeRDP_DesktopWidth, file->DesktopWidth); if (~file->DesktopHeight) freerdp_set_param_uint32(settings, FreeRDP_DesktopHeight, file->DesktopHeight); if (~file->SessionBpp) freerdp_set_param_uint32(settings, FreeRDP_ColorDepth, file->SessionBpp); if (~file->ConnectToConsole) freerdp_set_param_uint32(settings, FreeRDP_ConsoleSession, file->ConnectToConsole); if (~file->AdministrativeSession) freerdp_set_param_uint32(settings, FreeRDP_ConsoleSession, file->AdministrativeSession); if (~file->NegotiateSecurityLayer) freerdp_set_param_uint32(settings, FreeRDP_NegotiateSecurityLayer, file->NegotiateSecurityLayer); if (~file->EnableCredSSPSupport) freerdp_set_param_uint32(settings, FreeRDP_NlaSecurity, file->EnableCredSSPSupport); if (~((size_t) file->AlternateShell)) freerdp_set_param_string(settings, FreeRDP_AlternateShell, file->AlternateShell); if (~((size_t) file->ShellWorkingDirectory)) freerdp_set_param_string(settings, FreeRDP_ShellWorkingDirectory, file->ShellWorkingDirectory); if (~file->ScreenModeId) { /** * Screen Mode Id: * http://technet.microsoft.com/en-us/library/ff393692/ * * This setting corresponds to the selection in the Display * configuration slider on the Display tab under Options in RDC. * * Values: * * 0: The remote session will appear in a window. * 1: The remote session will appear full screen. */ freerdp_set_param_bool(settings, FreeRDP_Fullscreen, (file->ScreenModeId == 1) ? TRUE : FALSE); } if (~((size_t) file->LoadBalanceInfo)) { settings->LoadBalanceInfo = (BYTE*) _strdup(file->LoadBalanceInfo); settings->LoadBalanceInfoLength = (int) strlen((char*) settings->LoadBalanceInfo); } if (~file->AuthenticationLevel) { /** * Authentication Level: * http://technet.microsoft.com/en-us/library/ff393709/ * * This setting corresponds to the selection in the If server authentication * fails drop-down list on the Advanced tab under Options in RDC. * * Values: * * 0: If server authentication fails, connect to the computer without warning (Connect and don’t warn me). * 1: If server authentication fails, do not establish a connection (Do not connect). * 2: If server authentication fails, show a warning and allow me to connect or refuse the connection (Warn me). * 3: No authentication requirement is specified. */ freerdp_set_param_bool(settings, FreeRDP_IgnoreCertificate, (file->AuthenticationLevel == 0) ? TRUE : FALSE); } if (~file->ConnectionType) freerdp_set_param_uint32(settings, FreeRDP_ConnectionType, file->ConnectionType); if (~file->AudioMode) { if (file->AudioMode == AUDIO_MODE_REDIRECT) { freerdp_set_param_bool(settings, FreeRDP_AudioPlayback, TRUE); } else if (file->AudioMode == AUDIO_MODE_PLAY_ON_SERVER) { freerdp_set_param_bool(settings, FreeRDP_RemoteConsoleAudio, TRUE); } else if (file->AudioMode == AUDIO_MODE_NONE) { freerdp_set_param_bool(settings, FreeRDP_AudioPlayback, FALSE); freerdp_set_param_bool(settings, FreeRDP_RemoteConsoleAudio, FALSE); } } if (~file->Compression) freerdp_set_param_bool(settings, FreeRDP_CompressionEnabled, file->Compression); if (~((size_t) file->GatewayHostname)) freerdp_set_param_string(settings, FreeRDP_GatewayHostname, file->GatewayHostname); if (~file->GatewayUsageMethod) { freerdp_set_param_uint32(settings, FreeRDP_GatewayUsageMethod, file->GatewayUsageMethod); if (file->GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT) { freerdp_set_param_bool(settings, FreeRDP_GatewayEnabled, FALSE); freerdp_set_param_bool(settings, FreeRDP_GatewayBypassLocal, FALSE); } else if (file->GatewayUsageMethod == TSC_PROXY_MODE_DIRECT) { freerdp_set_param_bool(settings, FreeRDP_GatewayEnabled, TRUE); freerdp_set_param_bool(settings, FreeRDP_GatewayBypassLocal, FALSE); } else if (file->GatewayUsageMethod == TSC_PROXY_MODE_DETECT) { freerdp_set_param_bool(settings, FreeRDP_GatewayEnabled, TRUE); freerdp_set_param_bool(settings, FreeRDP_GatewayBypassLocal, TRUE); } else if (file->GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT) { /** * This corresponds to "Automatically detect RD Gateway server settings", * which means the client attempts to use gateway group policy settings * http://technet.microsoft.com/en-us/library/cc770601.aspx */ freerdp_set_param_bool(settings, FreeRDP_GatewayEnabled, FALSE); freerdp_set_param_bool(settings, FreeRDP_GatewayBypassLocal, FALSE); } else if (file->GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT) { freerdp_set_param_bool(settings, FreeRDP_GatewayEnabled, FALSE); freerdp_set_param_bool(settings, FreeRDP_GatewayBypassLocal, FALSE); } } if (~file->PromptCredentialOnce) freerdp_set_param_bool(settings, FreeRDP_GatewayUseSameCredentials, file->PromptCredentialOnce); if (~file->RemoteApplicationMode) freerdp_set_param_bool(settings, FreeRDP_RemoteApplicationMode, file->RemoteApplicationMode); if (~((size_t) file->RemoteApplicationProgram)) freerdp_set_param_string(settings, FreeRDP_RemoteApplicationProgram, file->RemoteApplicationProgram); if (~((size_t) file->RemoteApplicationName)) freerdp_set_param_string(settings, FreeRDP_RemoteApplicationName, file->RemoteApplicationName); if (~((size_t) file->RemoteApplicationIcon)) freerdp_set_param_string(settings, FreeRDP_RemoteApplicationIcon, file->RemoteApplicationIcon); if (~((size_t) file->RemoteApplicationFile)) freerdp_set_param_string(settings, FreeRDP_RemoteApplicationGuid, file->RemoteApplicationGuid); if (~((size_t) file->RemoteApplicationCmdLine)) freerdp_set_param_string(settings, FreeRDP_RemoteApplicationCmdLine, file->RemoteApplicationCmdLine); if (~file->SpanMonitors) freerdp_set_param_bool(settings, FreeRDP_SpanMonitors, file->SpanMonitors); if (~file->UseMultiMon) freerdp_set_param_bool(settings, FreeRDP_UseMultimon, file->UseMultiMon); if (~file->AllowFontSmoothing) freerdp_set_param_bool(settings, FreeRDP_AllowFontSmoothing, file->AllowFontSmoothing); if (~file->DisableWallpaper) freerdp_set_param_bool(settings, FreeRDP_DisableWallpaper, file->DisableWallpaper); if (~file->DisableFullWindowDrag) freerdp_set_param_bool(settings, FreeRDP_DisableFullWindowDrag, file->DisableFullWindowDrag); if (~file->DisableMenuAnims) freerdp_set_param_bool(settings, FreeRDP_DisableMenuAnims, file->DisableMenuAnims); if (~file->DisableThemes) freerdp_set_param_bool(settings, FreeRDP_DisableThemes, file->DisableThemes); if (~file->AllowDesktopComposition) freerdp_set_param_bool(settings, FreeRDP_AllowDesktopComposition, file->AllowDesktopComposition); if (~file->BitmapCachePersistEnable) freerdp_set_param_bool(settings, FreeRDP_BitmapCachePersistEnabled, file->BitmapCachePersistEnable); if (~file->DisableRemoteAppCapsCheck) freerdp_set_param_bool(settings, FreeRDP_DisableRemoteAppCapsCheck, file->DisableRemoteAppCapsCheck); if (~file->AutoReconnectionEnabled) freerdp_set_param_bool(settings, FreeRDP_AutoReconnectionEnabled, file->AutoReconnectionEnabled); if (~file->AutoReconnectMaxRetries) freerdp_set_param_uint32(settings, FreeRDP_AutoReconnectMaxRetries, file->AutoReconnectMaxRetries); if (~file->RedirectSmartCards) freerdp_set_param_bool(settings, FreeRDP_RedirectSmartCards, file->RedirectSmartCards); if (~file->RedirectClipboard) freerdp_set_param_bool(settings, FreeRDP_RedirectClipboard, file->RedirectClipboard); if (~file->RedirectPrinters) freerdp_set_param_bool(settings, FreeRDP_RedirectPrinters, file->RedirectPrinters); if (~file->RedirectDrives) freerdp_set_param_bool(settings, FreeRDP_RedirectDrives, file->RedirectDrives); if (~file->RedirectPosDevices) { freerdp_set_param_bool(settings, FreeRDP_RedirectSerialPorts, file->RedirectComPorts); freerdp_set_param_bool(settings, FreeRDP_RedirectParallelPorts, file->RedirectComPorts); } if (~file->RedirectComPorts) { freerdp_set_param_bool(settings, FreeRDP_RedirectSerialPorts, file->RedirectComPorts); freerdp_set_param_bool(settings, FreeRDP_RedirectParallelPorts, file->RedirectComPorts); } if (~file->RedirectDirectX) { /* What is this?! */ } if (~((size_t) file->DevicesToRedirect)) { /** * Devices to redirect: * http://technet.microsoft.com/en-us/library/ff393728/ * * This setting corresponds to the selections for Other supported Plug and Play * (PnP) devices under More on the Local Resources tab under Options in RDC. * * Values: * * '*': * Redirect all supported Plug and Play devices. * * 'DynamicDevices': * Redirect any supported Plug and Play devices that are connected later. * * The hardware ID for the supported Plug and Play device: * Redirect the specified supported Plug and Play device. * * Examples: * devicestoredirect:s:* * devicestoredirect:s:DynamicDevices * devicestoredirect:s:USB\VID_04A9&PID_30C1\6&4BD985D&0&2;,DynamicDevices * */ freerdp_set_param_bool(settings, FreeRDP_RedirectDrives, TRUE); } if (~((size_t) file->DrivesToRedirect)) { /* * Drives to redirect: * * Very similar to DevicesToRedirect, but can contain a * comma-separated list of drive letters to redirect. */ freerdp_set_param_bool(settings, FreeRDP_RedirectDrives, TRUE); } if (file->argc > 1) { char* ConnectionFile = settings->ConnectionFile; settings->ConnectionFile = NULL; freerdp_client_settings_parse_command_line(settings, file->argc, file->argv); settings->ConnectionFile = ConnectionFile; } return TRUE; }
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { int index; int status; HANDLE thread; wfContext* wfc; DWORD dwExitCode; rdpContext* context; rdpSettings* settings; RDP_CLIENT_ENTRY_POINTS clientEntryPoints; int ret = 0; ZeroMemory(&clientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS)); clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS); clientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION; RdpClientEntry(&clientEntryPoints); context = freerdp_client_context_new(&clientEntryPoints); settings = context->settings; wfc = (wfContext*) context; settings->SoftwareGdi = TRUE; context->argc = __argc; context->argv = (char**) malloc(sizeof(char*) * __argc); if (!context->argv) { ret = 1; goto out; } for (index = 0; index < context->argc; index++) { context->argv[index] = _strdup(__argv[index]); if (!context->argv[index]) { ret = 1; for (--index; index >= 0; --index) free(context->argv[index]); free(context->argv); context->argv = NULL; goto out; } } status = freerdp_client_settings_parse_command_line(settings, context->argc, context->argv, FALSE); status = freerdp_client_settings_command_line_status_print(settings, status, context->argc, context->argv); if (status) { freerdp_client_context_free(context); return 0; } freerdp_client_start(context); thread = freerdp_client_get_thread(context); WaitForSingleObject(thread, INFINITE); GetExitCodeThread(thread, &dwExitCode); freerdp_client_stop(context); out: freerdp_client_context_free(context); return ret; }
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { int index; int status; HANDLE thread; wfContext* wfc; DWORD dwExitCode; rdpContext* context; rdpSettings* settings; RDP_CLIENT_ENTRY_POINTS clientEntryPoints; int ret = 0; ZeroMemory(&clientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS)); clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS); clientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION; RdpClientEntry(&clientEntryPoints); #ifdef _CLIENT ////zhuxn/ TiRaChannel tira; int TiraStatus = tira.CreateSocket(); if (!TiraStatus) { return ret; } TiraStatus = tira.Accept(); if (!TiraStatus) { return ret; } // free(lpCmdLine); // lpCmdLine = NULL; char* pdata = NULL; TiraStatus = tira.RecvData(pdata); if (TiraStatus == -1) { return ret; } /////// #endif context = freerdp_client_context_new(&clientEntryPoints); settings = context->settings; wfc = (wfContext*) context; settings->SoftwareGdi = TRUE; ////////////////////////////////////////////////////////////////////////// #ifdef _CLIENT if (InitalArguments(context, pdata) == false) { ret = 1; goto out; } #else /*********************/ context->argc = __argc; context->argv = (char**)malloc(sizeof(char*) * __argc); if (!context->argv) { ret = 1; goto out; } for (index = 0; index < context->argc; index++) { context->argv[index] = _strdup(__argv[index]); if (!context->argv[index]) { ret = 1; for (--index; index >= 0; --index) free(context->argv[index]); free(context->argv); context->argv = NULL; goto out; } } /*********************/ #endif status = freerdp_client_settings_parse_command_line(settings, context->argc, context->argv, FALSE); status = freerdp_client_settings_command_line_status_print(settings, status, context->argc, context->argv); if (status) { freerdp_client_context_free(context); return 0; } freerdp_client_start(context); thread = freerdp_client_get_thread(context); WaitForSingleObject(thread, INFINITE); GetExitCodeThread(thread, &dwExitCode); freerdp_client_stop(context); out: freerdp_client_context_free(context); return ret; }