FreeRDP/server/proxy/pf_modules.c

/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * FreeRDP Proxy Server modules API
 *
 * Copyright 2019 Kobi Mizrachi <kmizrachi18@gmail.com>
 * Copyright 2019 Idan Freiberg <speidy@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.
 */

#include <assert.h>

#include <winpr/file.h>
#include <winpr/wlog.h>
#include <winpr/library.h>
#include <freerdp/api.h>
#include <freerdp/build-config.h>

#include "pf_log.h"
#include "pf_modules.h"
#include "pf_context.h"

#define TAG PROXY_TAG("modules")

#define MODULE_ENTRY_POINT "proxy_module_entry_point"

static wArrayList* plugins_list = NULL; /* list of all loaded plugins */
static wArrayList* handles_list = NULL; /* list of module handles to free at shutdown */

typedef BOOL (*moduleEntryPoint)(proxyPluginsManager* plugins_manager);

static const char* FILTER_TYPE_STRINGS[] = {
	"KEYBOARD_EVENT",
	"MOUSE_EVENT",
	"CLIENT_CHANNEL_DATA",
	"SERVER_CHANNEL_DATA",
};

static const char* HOOK_TYPE_STRINGS[] = {
	"CLIENT_PRE_CONNECT",   "CLIENT_LOGIN_FAILURE", "SERVER_POST_CONNECT",
	"SERVER_CHANNELS_INIT", "SERVER_CHANNELS_FREE",
};

static const char* pf_modules_get_filter_type_string(PF_FILTER_TYPE result)
{
	if (result >= FILTER_TYPE_KEYBOARD && result < FILTER_LAST)
		return FILTER_TYPE_STRINGS[result];
	else
		return "FILTER_UNKNOWN";
}

static const char* pf_modules_get_hook_type_string(PF_HOOK_TYPE result)
{
	if (result >= HOOK_TYPE_CLIENT_PRE_CONNECT && result < HOOK_LAST)
		return HOOK_TYPE_STRINGS[result];
	else
		return "HOOK_UNKNOWN";
}

/*
 * runs all hooks of type `type`.
 *
 * @type: hook type to run.
 * @server: pointer of server's rdpContext struct of the current session.
 */
BOOL pf_modules_run_hook(PF_HOOK_TYPE type, proxyData* pdata)
{
	BOOL ok = TRUE;
	int index;
	proxyPlugin* plugin;

	ArrayList_ForEach(plugins_list, proxyPlugin*, index, plugin)
	{
		WLog_VRB(TAG, "running hook %s.%s", plugin->name, pf_modules_get_hook_type_string(type));

		switch (type)
		{
			case HOOK_TYPE_CLIENT_PRE_CONNECT:
				IFCALLRET(plugin->ClientPreConnect, ok, pdata);
				break;

			case HOOK_TYPE_CLIENT_LOGIN_FAILURE:
				IFCALLRET(plugin->ClientLoginFailure, ok, pdata);
				break;

			case HOOK_TYPE_SERVER_POST_CONNECT:
				IFCALLRET(plugin->ServerPostConnect, ok, pdata);
				break;

			case HOOK_TYPE_SERVER_CHANNELS_INIT:
				IFCALLRET(plugin->ServerChannelsInit, ok, pdata);
				break;

			case HOOK_TYPE_SERVER_CHANNELS_FREE:
				IFCALLRET(plugin->ServerChannelsFree, ok, pdata);
				break;

			default:
				WLog_ERR(TAG, "invalid hook called");
		}

		if (!ok)
		{
			WLog_INFO(TAG, "plugin %s, hook %s failed!", plugin->name,
			          pf_modules_get_hook_type_string(type));
			return FALSE;
		}
	}

	return TRUE;
}

/*
 * runs all filters of type `type`.
 *
 * @type: filter type to run.
 * @server: pointer of server's rdpContext struct of the current session.
 */
BOOL pf_modules_run_filter(PF_FILTER_TYPE type, proxyData* pdata, void* param)
{
	BOOL result = TRUE;
	int index;
	proxyPlugin* plugin;

	ArrayList_ForEach(plugins_list, proxyPlugin*, index, plugin)
	{
		WLog_VRB(TAG, "[%s]: running filter: %s", __FUNCTION__, plugin->name);

		switch (type)
		{
			case FILTER_TYPE_KEYBOARD:
				IFCALLRET(plugin->KeyboardEvent, result, pdata, param);
				break;

			case FILTER_TYPE_MOUSE:
				IFCALLRET(plugin->MouseEvent, result, pdata, param);
				break;

			case FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_DATA:
				IFCALLRET(plugin->ClientChannelData, result, pdata, param);
				break;

			case FILTER_TYPE_SERVER_PASSTHROUGH_CHANNEL_DATA:
				IFCALLRET(plugin->ServerChannelData, result, pdata, param);
				break;
			default:
				WLog_ERR(TAG, "invalid filter called");
		}

		if (!result)
		{
			/* current filter return FALSE, no need to run other filters. */
			WLog_INFO(TAG, "plugin %s, filter type [%s] returned FALSE", plugin->name,
			          pf_modules_get_filter_type_string(type));
			return result;
		}
	}

	/* all filters returned TRUE */
	return TRUE;
}

/*
 * stores per-session data needed by a plugin.
 *
 * @context: current session server's rdpContext instance.
 * @info: pointer to per-session data.
 */
static BOOL pf_modules_set_plugin_data(const char* plugin_name, proxyData* pdata, void* data)
{
	union {
		const char* ccp;
		char* cp;
	} ccharconv;
	assert(plugin_name);

	ccharconv.ccp = plugin_name;
	if (data == NULL) /* no need to store anything */
		return FALSE;

	if (HashTable_Add(pdata->modules_info, ccharconv.cp, data) < 0)
	{
		WLog_ERR(TAG, "[%s]: HashTable_Add failed!");
		return FALSE;
	}

	return TRUE;
}

/*
 * returns per-session data needed a plugin.
 *
 * @context: current session server's rdpContext instance.
 * if there's no data related to `plugin_name` in `context` (current session), a NULL will be
 * returned.
 */
static void* pf_modules_get_plugin_data(const char* plugin_name, proxyData* pdata)
{
	union {
		const char* ccp;
		char* cp;
	} ccharconv;
	assert(plugin_name);
	assert(pdata);
	ccharconv.ccp = plugin_name;

	return HashTable_GetItemValue(pdata->modules_info, ccharconv.cp);
}

static void pf_modules_abort_connect(proxyData* pdata)
{
	assert(pdata);
	WLog_DBG(TAG, "%s is called!", __FUNCTION__);
	proxy_data_abort_connect(pdata);
}

static BOOL pf_modules_register_plugin(proxyPlugin* plugin_to_register)
{
	int index;
	proxyPlugin* plugin;

	if (!plugin_to_register)
		return FALSE;

	/* make sure there's no other loaded plugin with the same name of `plugin_to_register`. */
	ArrayList_ForEach(plugins_list, proxyPlugin*, index, plugin)
	{
		if (strcmp(plugin->name, plugin_to_register->name) == 0)
		{
			WLog_ERR(TAG, "can not register plugin '%s', it is already registered!", plugin->name);
			return FALSE;
		}
	}

	if (ArrayList_Add(plugins_list, plugin_to_register) < 0)
	{
		WLog_ERR(TAG, "[%s]: failed adding plugin to list: %s", __FUNCTION__,
		         plugin_to_register->name);
		return FALSE;
	}

	return TRUE;
}

BOOL pf_modules_is_plugin_loaded(const char* plugin_name)
{
	int i;
	proxyPlugin* plugin;

	if (plugins_list == NULL)
		return FALSE;

	ArrayList_ForEach(plugins_list, proxyPlugin*, i, plugin)
	{
		if (strcmp(plugin->name, plugin_name) == 0)
			return TRUE;
	}

	return FALSE;
}

void pf_modules_list_loaded_plugins(void)
{
	size_t count;
	int i;
	proxyPlugin* plugin;

	if (plugins_list == NULL)
		return;

	count = (size_t)ArrayList_Count(plugins_list);

	if (count > 0)
		WLog_INFO(TAG, "Loaded plugins:");

	ArrayList_ForEach(plugins_list, proxyPlugin*, i, plugin)
	{

		WLog_INFO(TAG, "\tName: %s", plugin->name);
		WLog_INFO(TAG, "\tDescription: %s", plugin->description);
	}
}

static proxyPluginsManager plugins_manager = { pf_modules_register_plugin,
	                                           pf_modules_set_plugin_data,
	                                           pf_modules_get_plugin_data,
	                                           pf_modules_abort_connect };

static BOOL pf_modules_load_module(const char* module_path)
{
	HMODULE handle = NULL;
	moduleEntryPoint pEntryPoint;
	handle = LoadLibraryA(module_path);

	if (handle == NULL)
	{
		WLog_ERR(TAG, "[%s]: failed loading external library: %s", __FUNCTION__, module_path);
		return FALSE;
	}

	if (!(pEntryPoint = (moduleEntryPoint)GetProcAddress(handle, MODULE_ENTRY_POINT)))
	{
		WLog_ERR(TAG, "[%s]: GetProcAddress failed while loading %s", __FUNCTION__, module_path);
		goto error;
	}

	if (!pEntryPoint(&plugins_manager))
	{
		WLog_ERR(TAG, "[%s]: module %s entry point failed!", __FUNCTION__, module_path);
		goto error;
	}

	/* save module handle for freeing the module later */
	if (ArrayList_Add(handles_list, handle) < 0)
	{
		WLog_ERR(TAG, "ArrayList_Add failed!");
		return FALSE;
	}

	return TRUE;

error:
	FreeLibrary(handle);
	return FALSE;
}

BOOL pf_modules_init(const char* root_dir, const char** modules, size_t count)
{
	size_t i;

	if (!PathFileExistsA(root_dir))
	{
		if (!CreateDirectoryA(root_dir, NULL))
		{
			WLog_ERR(TAG, "error occurred while creating modules directory: %s", root_dir);
			return FALSE;
		}

		return TRUE;
	}

	WLog_DBG(TAG, "modules root directory: %s", root_dir);

	plugins_list = ArrayList_New(FALSE);

	if (plugins_list == NULL)
	{
		WLog_ERR(TAG, "[%s]: ArrayList_New failed!", __FUNCTION__);
		goto error;
	}

	handles_list = ArrayList_New(FALSE);
	if (handles_list == NULL)
	{

		WLog_ERR(TAG, "[%s]: ArrayList_New failed!", __FUNCTION__);
		goto error;
	}

	for (i = 0; i < count; i++)
	{
		char* fullpath = GetCombinedPath(root_dir, modules[i]);
		pf_modules_load_module(fullpath);
		free(fullpath);
	}

	return TRUE;

error:
	ArrayList_Free(plugins_list);
	plugins_list = NULL;
	ArrayList_Free(handles_list);
	handles_list = NULL;
	return FALSE;
}

void pf_modules_free(void)
{
	int index;

	if (plugins_list)
	{
		proxyPlugin* plugin;

		ArrayList_ForEach(plugins_list, proxyPlugin*, index, plugin)
		{
			if (!IFCALLRESULT(TRUE, plugin->PluginUnload))
				WLog_WARN(TAG, "PluginUnload failed for plugin '%s'", plugin->name);
		}

		ArrayList_Free(plugins_list);
		plugins_list = NULL;
	}

	if (handles_list)
	{
		HANDLE handle;

		ArrayList_ForEach(handles_list, HANDLE, index, handle)
		{
			if (handle)
				FreeLibrary(handle);
		};

		ArrayList_Free(handles_list);
		handles_list = NULL;
	}
}