FreeRDP/libfreerdp/core/channels.c

/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * Virtual Channels
 *
 * Copyright 2011 Vic Lee
 * Copyright 2015 Copyright 2015 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <winpr/crt.h>
#include <winpr/stream.h>
#include <winpr/wtsapi.h>

#include <freerdp/freerdp.h>
#include <freerdp/constants.h>

#include <freerdp/log.h>
#include <freerdp/svc.h>
#include <freerdp/peer.h>
#include <freerdp/addin.h>

#include <freerdp/client/channels.h>
#include <freerdp/client/drdynvc.h>
#include <freerdp/channels/channels.h>

#include "rdp.h"
#include "client.h"
#include "server.h"
#include "channels.h"

#define TAG FREERDP_TAG("core.channels")

BOOL freerdp_channel_send(rdpRdp* rdp, UINT16 channelId, const BYTE* data, int size)
{
	DWORD i;
	int left;
	wStream* s;
	UINT32 flags;
	int chunkSize;
	rdpMcs* mcs = rdp->mcs;
	rdpMcsChannel* channel = NULL;

	for (i = 0; i < mcs->channelCount; i++)
	{
		if (mcs->channels[i].ChannelId == channelId)
		{
			channel = &mcs->channels[i];
			break;
		}
	}

	if (!channel)
	{
		WLog_ERR(TAG,  "freerdp_channel_send: unknown channelId %"PRIu16"", channelId);
		return FALSE;
	}

	flags = CHANNEL_FLAG_FIRST;
	left = size;

	while (left > 0)
	{
		s = rdp_send_stream_init(rdp);

		if (!s)
			return FALSE;

		if (left > (int) rdp->settings->VirtualChannelChunkSize)
		{
			chunkSize = rdp->settings->VirtualChannelChunkSize;
		}
		else
		{
			chunkSize = left;
			flags |= CHANNEL_FLAG_LAST;
		}

		if ((channel->options & CHANNEL_OPTION_SHOW_PROTOCOL))
		{
			flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
		}

		Stream_Write_UINT32(s, size);
		Stream_Write_UINT32(s, flags);

		if (!Stream_EnsureCapacity(s, chunkSize))
		{
			Stream_Release(s);
			return FALSE;
		}

		Stream_Write(s, data, chunkSize);

		/* WLog_DBG(TAG, "%s: sending data (flags=0x%x size=%d)", __FUNCTION__, flags, size); */
		if (!rdp_send(rdp, s, channelId))
			return FALSE;

		data += chunkSize;
		left -= chunkSize;
		flags = 0;
	}

	return TRUE;
}

BOOL freerdp_channel_process(freerdp* instance, wStream* s, UINT16 channelId)
{
	UINT32 length;
	UINT32 flags;
	int chunkLength;

	if (Stream_GetRemainingLength(s) < 8)
		return FALSE;

	Stream_Read_UINT32(s, length);
	Stream_Read_UINT32(s, flags);
	chunkLength = Stream_GetRemainingLength(s);
	IFCALL(instance->ReceiveChannelData, instance,
	       channelId, Stream_Pointer(s), chunkLength, flags, length);
	return TRUE;
}

BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s,
                                  UINT16 channelId)
{
	UINT32 length;
	UINT32 flags;
	int chunkLength;

	if (Stream_GetRemainingLength(s) < 8)
		return FALSE;

	Stream_Read_UINT32(s, length);
	Stream_Read_UINT32(s, flags);
	chunkLength = Stream_GetRemainingLength(s);

	if (client->VirtualChannelRead)
	{
		UINT32 index;
		BOOL found = FALSE;
		HANDLE hChannel = 0;
		rdpContext* context = client->context;
		rdpMcs* mcs = context->rdp->mcs;
		rdpMcsChannel* mcsChannel = NULL;

		for (index = 0; index < mcs->channelCount; index++)
		{
			mcsChannel = &(mcs->channels[index]);

			if (mcsChannel->ChannelId == channelId)
			{
				hChannel = (HANDLE) mcsChannel->handle;
				found = TRUE;
				break;
			}
		}

		if (!found)
			return FALSE;

		client->VirtualChannelRead(client, hChannel, Stream_Pointer(s),
		                           Stream_GetRemainingLength(s));
	}
	else if (client->ReceiveChannelData)
	{
		client->ReceiveChannelData(client, channelId, Stream_Pointer(s), chunkLength,
		                           flags, length);
	}

	return TRUE;
}

static const WtsApiFunctionTable FreeRDP_WtsApiFunctionTable =
{
	0, /* dwVersion */
	0, /* dwFlags */

	FreeRDP_WTSStopRemoteControlSession, /* StopRemoteControlSession */
	FreeRDP_WTSStartRemoteControlSessionW, /* StartRemoteControlSessionW */
	FreeRDP_WTSStartRemoteControlSessionA, /* StartRemoteControlSessionA */
	FreeRDP_WTSConnectSessionW, /* ConnectSessionW */
	FreeRDP_WTSConnectSessionA, /* ConnectSessionA */
	FreeRDP_WTSEnumerateServersW, /* EnumerateServersW */
	FreeRDP_WTSEnumerateServersA, /* EnumerateServersA */
	FreeRDP_WTSOpenServerW, /* OpenServerW */
	FreeRDP_WTSOpenServerA, /* OpenServerA */
	FreeRDP_WTSOpenServerExW, /* OpenServerExW */
	FreeRDP_WTSOpenServerExA, /* OpenServerExA */
	FreeRDP_WTSCloseServer, /* CloseServer */
	FreeRDP_WTSEnumerateSessionsW, /* EnumerateSessionsW */
	FreeRDP_WTSEnumerateSessionsA, /* EnumerateSessionsA */
	FreeRDP_WTSEnumerateSessionsExW, /* EnumerateSessionsExW */
	FreeRDP_WTSEnumerateSessionsExA, /* EnumerateSessionsExA */
	FreeRDP_WTSEnumerateProcessesW, /* EnumerateProcessesW */
	FreeRDP_WTSEnumerateProcessesA, /* EnumerateProcessesA */
	FreeRDP_WTSTerminateProcess, /* TerminateProcess */
	FreeRDP_WTSQuerySessionInformationW, /* QuerySessionInformationW */
	FreeRDP_WTSQuerySessionInformationA, /* QuerySessionInformationA */
	FreeRDP_WTSQueryUserConfigW, /* QueryUserConfigW */
	FreeRDP_WTSQueryUserConfigA, /* QueryUserConfigA */
	FreeRDP_WTSSetUserConfigW, /* SetUserConfigW */
	FreeRDP_WTSSetUserConfigA, /* SetUserConfigA */
	FreeRDP_WTSSendMessageW, /* SendMessageW */
	FreeRDP_WTSSendMessageA, /* SendMessageA */
	FreeRDP_WTSDisconnectSession, /* DisconnectSession */
	FreeRDP_WTSLogoffSession, /* LogoffSession */
	FreeRDP_WTSShutdownSystem, /* ShutdownSystem */
	FreeRDP_WTSWaitSystemEvent, /* WaitSystemEvent */
	FreeRDP_WTSVirtualChannelOpen, /* VirtualChannelOpen */
	FreeRDP_WTSVirtualChannelOpenEx, /* VirtualChannelOpenEx */
	FreeRDP_WTSVirtualChannelClose, /* VirtualChannelClose */
	FreeRDP_WTSVirtualChannelRead, /* VirtualChannelRead */
	FreeRDP_WTSVirtualChannelWrite, /* VirtualChannelWrite */
	FreeRDP_WTSVirtualChannelPurgeInput, /* VirtualChannelPurgeInput */
	FreeRDP_WTSVirtualChannelPurgeOutput, /* VirtualChannelPurgeOutput */
	FreeRDP_WTSVirtualChannelQuery, /* VirtualChannelQuery */
	FreeRDP_WTSFreeMemory, /* FreeMemory */
	FreeRDP_WTSRegisterSessionNotification, /* RegisterSessionNotification */
	FreeRDP_WTSUnRegisterSessionNotification, /* UnRegisterSessionNotification */
	FreeRDP_WTSRegisterSessionNotificationEx, /* RegisterSessionNotificationEx */
	FreeRDP_WTSUnRegisterSessionNotificationEx, /* UnRegisterSessionNotificationEx */
	FreeRDP_WTSQueryUserToken, /* QueryUserToken */
	FreeRDP_WTSFreeMemoryExW, /* FreeMemoryExW */
	FreeRDP_WTSFreeMemoryExA, /* FreeMemoryExA */
	FreeRDP_WTSEnumerateProcessesExW, /* EnumerateProcessesExW */
	FreeRDP_WTSEnumerateProcessesExA, /* EnumerateProcessesExA */
	FreeRDP_WTSEnumerateListenersW, /* EnumerateListenersW */
	FreeRDP_WTSEnumerateListenersA, /* EnumerateListenersA */
	FreeRDP_WTSQueryListenerConfigW, /* QueryListenerConfigW */
	FreeRDP_WTSQueryListenerConfigA, /* QueryListenerConfigA */
	FreeRDP_WTSCreateListenerW, /* CreateListenerW */
	FreeRDP_WTSCreateListenerA, /* CreateListenerA */
	FreeRDP_WTSSetListenerSecurityW, /* SetListenerSecurityW */
	FreeRDP_WTSSetListenerSecurityA, /* SetListenerSecurityA */
	FreeRDP_WTSGetListenerSecurityW, /* GetListenerSecurityW */
	FreeRDP_WTSGetListenerSecurityA, /* GetListenerSecurityA */
	FreeRDP_WTSEnableChildSessions, /* EnableChildSessions */
	FreeRDP_WTSIsChildSessionsEnabled, /* IsChildSessionsEnabled */
	FreeRDP_WTSGetChildSessionId, /* GetChildSessionId */
	FreeRDP_WTSGetActiveConsoleSessionId, /* GetActiveConsoleSessionId */
	FreeRDP_WTSLogonUser,
	FreeRDP_WTSLogoffUser,
	FreeRDP_WTSStartRemoteControlSessionExW,
	FreeRDP_WTSStartRemoteControlSessionExA
};

PWtsApiFunctionTable FreeRDP_InitWtsApi(void)
{
	return (PWtsApiFunctionTable)&FreeRDP_WtsApiFunctionTable;
}