FreeRDP/server/shadow/shadow_server.c

694 lines
15 KiB
C
Raw Normal View History

/**
* FreeRDP: A Remote Desktop Protocol Implementation
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* 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 <winpr/crt.h>
2014-08-15 21:50:22 +04:00
#include <winpr/ssl.h>
2014-08-14 21:10:43 +04:00
#include <winpr/wnd.h>
#include <winpr/path.h>
#include <winpr/cmdline.h>
#include <winpr/winsock.h>
2014-09-12 19:38:12 +04:00
#include <freerdp/log.h>
#include <freerdp/version.h>
#include <winpr/tools/makecert.h>
#ifndef _WIN32
#include <sys/select.h>
2015-02-02 19:48:54 +03:00
#include <signal.h>
#endif
#include "shadow.h"
2014-09-12 19:38:12 +04:00
#define TAG SERVER_TAG("shadow")
static COMMAND_LINE_ARGUMENT_A shadow_args[] =
{
{ "port", COMMAND_LINE_VALUE_REQUIRED, "<number>", NULL, NULL, -1, NULL, "Server port" },
{ "ipc-socket", COMMAND_LINE_VALUE_REQUIRED, "<ipc-socket>", NULL, NULL, -1, NULL, "Server IPC socket" },
{ "monitors", COMMAND_LINE_VALUE_OPTIONAL, "<0,1,2...>", NULL, NULL, -1, NULL, "Select or list monitors" },
{ "rect", COMMAND_LINE_VALUE_REQUIRED, "<x,y,w,h>", NULL, NULL, -1, NULL, "Select rectangle within monitor to share" },
2014-09-27 03:03:48 +04:00
{ "auth", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueFalse, NULL, -1, NULL, "Clients must authenticate" },
2014-07-15 02:01:29 +04:00
{ "may-view", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueTrue, NULL, -1, NULL, "Clients may view without prompt" },
{ "may-interact", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueTrue, NULL, -1, NULL, "Clients may interact without prompt" },
{ "version", COMMAND_LINE_VALUE_FLAG | COMMAND_LINE_PRINT_VERSION, NULL, NULL, NULL, -1, NULL, "Print version" },
{ "help", COMMAND_LINE_VALUE_FLAG | COMMAND_LINE_PRINT_HELP, NULL, NULL, NULL, -1, "?", "Print help" },
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
};
int shadow_server_print_command_line_help(int argc, char** argv)
{
char* str;
int length;
COMMAND_LINE_ARGUMENT_A* arg;
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "Usage: %s [options]", argv[0]);
WLog_INFO(TAG, "");
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "Syntax:");
WLog_INFO(TAG, " /flag (enables flag)");
WLog_INFO(TAG, " /option:<value> (specifies option with value)");
WLog_INFO(TAG, " +toggle -toggle (enables or disables toggle, where '/' is a synonym of '+')");
WLog_INFO(TAG, "");
arg = shadow_args;
do
{
if (arg->Flags & COMMAND_LINE_VALUE_FLAG)
{
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, " %s", "/");
WLog_INFO(TAG, "%-20s", arg->Name);
WLog_INFO(TAG, "\t%s", arg->Text);
}
else if ((arg->Flags & COMMAND_LINE_VALUE_REQUIRED) || (arg->Flags & COMMAND_LINE_VALUE_OPTIONAL))
{
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, " %s", "/");
if (arg->Format)
{
length = (int) (strlen(arg->Name) + strlen(arg->Format) + 2);
str = (char*) malloc(length + 1);
sprintf_s(str, length + 1, "%s:%s", arg->Name, arg->Format);
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "%-20s", str);
free(str);
}
else
{
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "%-20s", arg->Name);
}
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "\t%s", arg->Text);
}
else if (arg->Flags & COMMAND_LINE_VALUE_BOOL)
{
length = (int) strlen(arg->Name) + 32;
str = (char*) malloc(length + 1);
sprintf_s(str, length + 1, "%s (default:%s)", arg->Name,
arg->Default ? "on" : "off");
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, " %s", arg->Default ? "-" : "+");
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "%-20s", str);
free(str);
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "\t%s", arg->Text);
}
}
while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
return 1;
}
int shadow_server_command_line_status_print(rdpShadowServer* server, int argc, char** argv, int status)
{
if (status == COMMAND_LINE_STATUS_PRINT_VERSION)
{
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, "FreeRDP version %s (git %s)", FREERDP_VERSION_FULL, GIT_REVISION);
return COMMAND_LINE_STATUS_PRINT_VERSION;
}
else if (status == COMMAND_LINE_STATUS_PRINT)
{
return COMMAND_LINE_STATUS_PRINT;
}
else if (status < 0)
{
shadow_server_print_command_line_help(argc, argv);
return COMMAND_LINE_STATUS_PRINT_HELP;
}
return 1;
}
int shadow_server_parse_command_line(rdpShadowServer* server, int argc, char** argv)
{
int status;
DWORD flags;
COMMAND_LINE_ARGUMENT_A* arg;
if (argc < 2)
return 1;
CommandLineClearArgumentsA(shadow_args);
flags = COMMAND_LINE_SEPARATOR_COLON;
flags |= COMMAND_LINE_SIGIL_SLASH | COMMAND_LINE_SIGIL_PLUS_MINUS;
status = CommandLineParseArgumentsA(argc, (const char**) argv, shadow_args, flags, server, NULL, NULL);
if (status < 0)
return status;
arg = shadow_args;
do
{
if (!(arg->Flags & COMMAND_LINE_ARGUMENT_PRESENT))
continue;
CommandLineSwitchStart(arg)
CommandLineSwitchCase(arg, "port")
{
server->port = (DWORD) atoi(arg->Value);
}
CommandLineSwitchCase(arg, "ipc-socket")
{
server->ipcSocket = _strdup(arg->Value);
}
2014-07-15 02:01:29 +04:00
CommandLineSwitchCase(arg, "may-view")
{
server->mayView = arg->Value ? TRUE : FALSE;
}
CommandLineSwitchCase(arg, "may-interact")
{
server->mayInteract = arg->Value ? TRUE : FALSE;
}
CommandLineSwitchCase(arg, "rect")
{
char* p;
char* tok[4];
int x, y, w, h;
char* str = _strdup(arg->Value);
if (!str)
return -1;
tok[0] = p = str;
p = strchr(p + 1, ',');
if (!p)
return -1;
*p++ = '\0';
tok[1] = p;
p = strchr(p + 1, ',');
if (!p)
return -1;
*p++ = '\0';
tok[2] = p;
p = strchr(p + 1, ',');
if (!p)
return -1;
*p++ = '\0';
tok[3] = p;
x = atoi(tok[0]);
y = atoi(tok[1]);
w = atoi(tok[2]);
h = atoi(tok[3]);
if ((x < 0) || (y < 0) || (w < 1) || (h < 1))
return -1;
server->subRect.left = x;
server->subRect.top = y;
server->subRect.right = x + w;
server->subRect.bottom = y + h;
server->shareSubRect = TRUE;
}
2014-09-27 03:03:48 +04:00
CommandLineSwitchCase(arg, "auth")
{
server->authentication = arg->Value ? TRUE : FALSE;
}
CommandLineSwitchDefault(arg)
{
2014-07-15 02:01:29 +04:00
}
CommandLineSwitchEnd(arg)
}
while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
arg = CommandLineFindArgumentA(shadow_args, "monitors");
2014-07-15 02:01:29 +04:00
if (arg && (arg->Flags & COMMAND_LINE_ARGUMENT_PRESENT))
{
int index;
int numMonitors;
MONITOR_DEF monitors[16];
numMonitors = shadow_enum_monitors(monitors, 16, 0);
if (arg->Flags & COMMAND_LINE_VALUE_PRESENT)
{
/* Select monitors */
index = atoi(arg->Value);
if (index < 0)
index = 0;
if (index >= numMonitors)
index = 0;
server->selectedMonitor = index;
}
else
{
int width, height;
MONITOR_DEF* monitor;
/* List monitors */
for (index = 0; index < numMonitors; index++)
{
monitor = &monitors[index];
width = monitor->right - monitor->left;
height = monitor->bottom - monitor->top;
2014-09-12 19:38:12 +04:00
WLog_INFO(TAG, " %s [%d] %dx%d\t+%d+%d",
(monitor->flags == 1) ? "*" : " ", index,
width, height, monitor->left, monitor->top);
}
status = COMMAND_LINE_STATUS_PRINT;
}
}
return status;
}
void* shadow_server_thread(rdpShadowServer* server)
{
2014-07-11 01:20:41 +04:00
DWORD status;
DWORD nCount;
HANDLE events[32];
2014-07-12 09:18:08 +04:00
HANDLE StopEvent;
2014-07-11 01:20:41 +04:00
freerdp_listener* listener;
rdpShadowSubsystem* subsystem;
2014-07-11 01:20:41 +04:00
listener = server->listener;
2014-07-12 09:18:08 +04:00
StopEvent = server->StopEvent;
subsystem = server->subsystem;
2014-07-11 01:20:41 +04:00
2014-09-18 23:43:11 +04:00
shadow_subsystem_start(server->subsystem);
2014-07-14 03:42:57 +04:00
2014-07-11 01:20:41 +04:00
while (1)
{
nCount = listener->GetEventHandles(listener, events, 32);
if (0 == nCount)
2014-07-11 01:20:41 +04:00
{
2014-09-12 19:38:12 +04:00
WLog_ERR(TAG, "Failed to get FreeRDP file descriptor");
2014-07-11 01:20:41 +04:00
break;
}
2014-07-12 09:18:08 +04:00
events[nCount++] = server->StopEvent;
2014-07-11 01:20:41 +04:00
status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
2014-07-12 09:18:08 +04:00
if (WaitForSingleObject(server->StopEvent, 0) == WAIT_OBJECT_0)
{
break;
}
2014-07-11 01:20:41 +04:00
if (!listener->CheckFileDescriptor(listener))
{
2014-09-12 19:38:12 +04:00
WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
2014-07-11 01:20:41 +04:00
break;
}
2014-08-16 02:12:53 +04:00
#ifdef _WIN32
Sleep(100); /* FIXME: listener event handles */
#endif
2014-07-11 01:20:41 +04:00
}
listener->Close(listener);
2014-09-18 23:43:11 +04:00
shadow_subsystem_stop(server->subsystem);
ExitThread(0);
return NULL;
}
2014-07-11 01:20:41 +04:00
int shadow_server_start(rdpShadowServer* server)
{
BOOL status;
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
return -1;
#ifndef _WIN32
signal(SIGPIPE, SIG_IGN);
#endif
server->screen = shadow_screen_new(server);
if (!server->screen)
return -1;
server->capture = shadow_capture_new(server);
if (!server->capture)
return -1;
if (!server->ipcSocket)
status = server->listener->Open(server->listener, NULL, (UINT16) server->port);
else
status = server->listener->OpenLocal(server->listener, server->ipcSocket);
if (!status)
return -1;
if (!(server->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)
shadow_server_thread, (void*) server, 0, NULL)))
{
return -1;
}
return 0;
}
2014-07-11 01:20:41 +04:00
int shadow_server_stop(rdpShadowServer* server)
{
if (server->thread)
{
2014-07-12 09:18:08 +04:00
SetEvent(server->StopEvent);
WaitForSingleObject(server->thread, INFINITE);
CloseHandle(server->thread);
2014-07-12 09:18:08 +04:00
server->thread = NULL;
server->listener->Close(server->listener);
}
if (server->screen)
{
shadow_screen_free(server->screen);
server->screen = NULL;
}
if (server->capture)
{
shadow_capture_free(server->capture);
server->capture = NULL;
}
return 0;
}
int shadow_server_init_config_path(rdpShadowServer* server)
{
#ifdef _WIN32
if (!server->ConfigPath)
{
server->ConfigPath = GetEnvironmentSubPath("LOCALAPPDATA", "freerdp");
}
#endif
#ifdef __APPLE__
if (!server->ConfigPath)
{
char* userLibraryPath;
char* userApplicationSupportPath;
userLibraryPath = GetKnownSubPath(KNOWN_PATH_HOME, "Library");
if (userLibraryPath)
{
2015-05-05 20:45:34 +03:00
if (!PathFileExistsA(userLibraryPath) &&
!CreateDirectoryA(userLibraryPath, 0))
{
WLog_ERR(TAG, "Failed to create directory '%s'", userLibraryPath);
2015-05-05 20:45:34 +03:00
free(userLibraryPath);
return -1;
}
userApplicationSupportPath = GetCombinedPath(userLibraryPath, "Application Support");
if (userApplicationSupportPath)
{
2015-05-05 20:45:34 +03:00
if (!PathFileExistsA(userApplicationSupportPath) &&
!CreateDirectoryA(userApplicationSupportPath, 0))
{
WLog_ERR(TAG, "Failed to create directory '%s'", userApplicationSupportPath);
free(userLibraryPath);
free(userApplicationSupportPath);
return -1;
}
server->ConfigPath = GetCombinedPath(userApplicationSupportPath, "freerdp");
}
free(userLibraryPath);
free(userApplicationSupportPath);
}
}
#endif
if (!server->ConfigPath)
{
char* configHome;
configHome = GetKnownPath(KNOWN_PATH_XDG_CONFIG_HOME);
if (configHome)
{
2015-05-05 20:45:34 +03:00
if (!PathFileExistsA(configHome) &&
!CreateDirectoryA(configHome, 0))
{
WLog_ERR(TAG, "Failed to create directory '%s'", configHome);
free(configHome);
return -1;
}
server->ConfigPath = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, "freerdp");
free(configHome);
}
}
if (!server->ConfigPath)
return -1; /* no usable config path */
return 1;
}
int shadow_server_init_certificate(rdpShadowServer* server)
{
char* filepath;
MAKECERT_CONTEXT* makecert;
const char* makecert_argv[6] =
{
"makecert",
"-rdp",
"-live",
"-silent",
"-y", "5"
};
int makecert_argc = (sizeof(makecert_argv) / sizeof(char*));
2015-05-05 20:45:34 +03:00
if (!PathFileExistsA(server->ConfigPath) &&
!CreateDirectoryA(server->ConfigPath, 0))
{
WLog_ERR(TAG, "Failed to create directory '%s'", server->ConfigPath);
return -1;
}
2015-05-05 20:45:34 +03:00
if (!(filepath = GetCombinedPath(server->ConfigPath, "shadow")))
return -1;
2015-05-05 20:45:34 +03:00
if (!PathFileExistsA(filepath) &&
!CreateDirectoryA(filepath, 0))
{
WLog_ERR(TAG, "Failed to create directory '%s'", filepath);
free(filepath);
return -1;
}
server->CertificateFile = GetCombinedPath(filepath, "shadow.crt");
server->PrivateKeyFile = GetCombinedPath(filepath, "shadow.key");
if ((!PathFileExistsA(server->CertificateFile)) ||
(!PathFileExistsA(server->PrivateKeyFile)))
{
makecert = makecert_context_new();
makecert_context_process(makecert, makecert_argc, (char**) makecert_argv);
makecert_context_set_output_file_name(makecert, "shadow");
if (!PathFileExistsA(server->CertificateFile))
makecert_context_output_certificate_file(makecert, filepath);
if (!PathFileExistsA(server->PrivateKeyFile))
makecert_context_output_private_key_file(makecert, filepath);
makecert_context_free(makecert);
}
free(filepath);
return 1;
}
int shadow_server_init(rdpShadowServer* server)
{
int status;
2014-08-15 21:50:22 +04:00
winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
2014-07-15 02:01:29 +04:00
WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
if (!(server->clients = ArrayList_New(TRUE)))
goto fail_client_array;
if (!(server->StopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
goto fail_stop_event;
2014-07-12 09:18:08 +04:00
if (!InitializeCriticalSectionAndSpinCount(&(server->lock), 4000))
goto fail_server_lock;
status = shadow_server_init_config_path(server);
if (status < 0)
goto fail_config_path;
status = shadow_server_init_certificate(server);
if (status < 0)
goto fail_certificate;
server->listener = freerdp_listener_new();
if (!server->listener)
goto fail_listener;
server->listener->info = (void*) server;
server->listener->PeerAccepted = shadow_client_accepted;
2014-09-18 23:43:11 +04:00
server->subsystem = shadow_subsystem_new(NULL);
if (!server->subsystem)
goto fail_subsystem_new;
status = shadow_subsystem_init(server->subsystem, server);
if (status >= 0)
return status;
fail_subsystem_new:
freerdp_listener_free(server->listener);
server->listener = NULL;
fail_listener:
free(server->CertificateFile);
server->CertificateFile = NULL;
free(server->PrivateKeyFile);
server->PrivateKeyFile = NULL;
fail_certificate:
free(server->ConfigPath);
server->ConfigPath = NULL;
fail_config_path:
DeleteCriticalSection(&(server->lock));
fail_server_lock:
CloseHandle(server->StopEvent);
server->StopEvent = NULL;
fail_stop_event:
ArrayList_Free(server->clients);
server->clients = NULL;
fail_client_array:
WLog_ERR(TAG, "Failed to initialize shadow server");
return -1;
}
int shadow_server_uninit(rdpShadowServer* server)
{
shadow_server_stop(server);
if (server->listener)
{
freerdp_listener_free(server->listener);
server->listener = NULL;
}
if (server->CertificateFile)
{
free(server->CertificateFile);
server->CertificateFile = NULL;
}
if (server->PrivateKeyFile)
{
free(server->PrivateKeyFile);
server->PrivateKeyFile = NULL;
}
if (server->ipcSocket)
{
free(server->ipcSocket);
server->ipcSocket = NULL;
}
shadow_subsystem_uninit(server->subsystem);
return 1;
}
rdpShadowServer* shadow_server_new()
{
rdpShadowServer* server;
server = (rdpShadowServer*) calloc(1, sizeof(rdpShadowServer));
if (!server)
2014-07-12 04:49:56 +04:00
return NULL;
server->port = 3389;
2014-07-15 02:01:29 +04:00
server->mayView = TRUE;
server->mayInteract = TRUE;
2014-09-27 03:03:48 +04:00
#ifdef WITH_SHADOW_X11
server->authentication = TRUE;
#else
server->authentication = FALSE;
#endif
return server;
}
2014-07-11 01:20:41 +04:00
void shadow_server_free(rdpShadowServer* server)
{
if (!server)
return;
DeleteCriticalSection(&(server->lock));
if (server->clients)
{
ArrayList_Free(server->clients);
server->clients = NULL;
}
2014-09-18 23:43:11 +04:00
shadow_subsystem_free(server->subsystem);
free(server);
}