/**
* Send a plugin-defined event to the plugin.
* called only from main thread
* @param channels the channel manager instance
* @param event an event object created by freerdp_event_new()
*/
FREERDP_API int freerdp_channels_send_event(rdpChannels* chan_man, RDP_EVENT* event)
{
struct channel_data* lchan_data;
int index;
const char* name;
name = event_class_to_name_table[event->event_class];
if (name == NULL)
{
DEBUG_CHANNELS("unknown event_class %d", event->event_class);
freerdp_event_free(event);
return 1;
}
lchan_data = freerdp_channels_find_channel_data_by_name(chan_man, name, &index);
if (lchan_data == NULL)
{
DEBUG_CHANNELS("could not find channel name %s", name);
freerdp_event_free(event);
return 1;
}
if (lchan_data->open_event_proc != NULL)
{
lchan_data->open_event_proc(lchan_data->open_handle,
CHANNEL_EVENT_USER,
event, sizeof(RDP_EVENT), sizeof(RDP_EVENT), 0);
}
return 0;
}
/**
* go through and inform all the libraries that we are initialized
* called only from main thread
*/
int freerdp_channels_pre_connect(rdpChannels* chan_man, freerdp* instance)
{
int index;
struct lib_data* llib;
CHANNEL_DEF lchannel_def;
void* dummy;
DEBUG_CHANNELS("enter");
chan_man->instance = instance;
/**
* If rdpsnd is registered but not rdpdr, it's necessary to register a fake
* rdpdr channel to make sound work. This is a workaround for Window 7 and
* Windows 2008
*/
if (freerdp_channels_find_channel_data_by_name(chan_man, "rdpsnd", 0) != 0 &&
freerdp_channels_find_channel_data_by_name(chan_man, "rdpdr", 0) == 0)
{
lchannel_def.options = CHANNEL_OPTION_INITIALIZED |
CHANNEL_OPTION_ENCRYPT_RDP;
strcpy(lchannel_def.name, "rdpdr");
chan_man->can_call_init = 1;
chan_man->settings = instance->settings;
freerdp_mutex_lock(g_mutex_init);
g_init_chan_man = chan_man;
MyVirtualChannelInit(&dummy, &lchannel_def, 1,
VIRTUAL_CHANNEL_VERSION_WIN2000, 0);
g_init_chan_man = NULL;
freerdp_mutex_unlock(g_mutex_init);
chan_man->can_call_init = 0;
chan_man->settings = 0;
DEBUG_CHANNELS("registered fake rdpdr for rdpsnd.");
}
for (index = 0; index < chan_man->num_libs; index++)
{
llib = chan_man->libs + index;
if (llib->init_event_proc != 0)
{
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_INITIALIZED,
0, 0);
}
}
return 0;
}
/**
* can be called from any thread
* thread safe because no 2 threads can have the same channel name registered
*/
static UINT32 FREERDP_CC MyVirtualChannelOpen(void* pInitHandle, UINT32* pOpenHandle,
char* pChannelName, PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
{
int index;
rdpChannels* channels;
struct channel_data* lchannel_data;
DEBUG_CHANNELS("enter");
channels = ((rdpInitHandle*) pInitHandle)->channels;
if (pOpenHandle == 0)
{
DEBUG_CHANNELS("error bad channel handle");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (pChannelOpenEventProc == 0)
{
DEBUG_CHANNELS("error bad proc");
return CHANNEL_RC_BAD_PROC;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, pChannelName, &index);
if (lchannel_data == 0)
{
DEBUG_CHANNELS("error channel name");
return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
}
if (lchannel_data->flags == 2)
{
DEBUG_CHANNELS("error channel already open");
return CHANNEL_RC_ALREADY_OPEN;
}
lchannel_data->flags = 2; /* open */
lchannel_data->open_event_proc = pChannelOpenEventProc;
*pOpenHandle = lchannel_data->open_handle;
return CHANNEL_RC_OK;
}
/**
* Send a plugin-defined event to the plugin.
* called only from main thread
* @param channels the channel manager instance
* @param event an event object created by freerdp_event_new()
*/
FREERDP_API int freerdp_channels_send_event(rdpChannels* channels, wMessage* event)
{
int index;
const char* name = NULL;
rdpChannelData* lchannel_data;
switch (GetMessageClass(event->id))
{
case DebugChannel_Class:
name = "rdpdbg";
break;
case CliprdrChannel_Class:
name = "cliprdr";
break;
case TsmfChannel_Class:
name = "tsmf";
break;
case RailChannel_Class:
name = "rail";
break;
}
if (!name)
{
DEBUG_CHANNELS("unknown event_class %d", event->event_class);
freerdp_event_free(event);
return 1;
}
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, name, &index);
if (!lchannel_data)
{
DEBUG_CHANNELS("could not find channel name %s", name);
freerdp_event_free(event);
return 1;
}
if (lchannel_data->open_event_proc)
{
lchannel_data->open_event_proc(lchannel_data->open_handle, CHANNEL_EVENT_USER,
event, sizeof(wMessage), sizeof(wMessage), 0);
}
return 0;
}
/**
* data comming from the server to the client
* called only from main thread
*/
int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int data_size, int flags, int total_size)
{
int index;
rdpChannels* channels;
rdpChannel* lrdp_channel;
struct channel_data* lchannel_data;
channels = freerdp_channels_find_by_instance(instance);
if (channels == 0)
{
DEBUG_CHANNELS("could not find channel manager");
return 1;
}
lrdp_channel = freerdp_channels_find_channel_by_id(channels, instance->settings,
channel_id, &index);
if (lrdp_channel == 0)
{
DEBUG_CHANNELS("could not find channel id");
return 1;
}
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, lrdp_channel->Name, &index);
if (lchannel_data == 0)
{
DEBUG_CHANNELS("could not find channel name");
return 1;
}
if (lchannel_data->open_event_proc != 0)
{
lchannel_data->open_event_proc(lchannel_data->open_handle,
CHANNEL_EVENT_DATA_RECEIVED, data, data_size, total_size, flags);
}
return 0;
}
/**
* must be called by same thread that calls freerdp_chanman_load_plugin
* according to MS docs
* only called from main thread
*/
static uint32 FREERDP_CC MyVirtualChannelInit(void** ppInitHandle, PCHANNEL_DEF pChannel,
int channelCount, uint32 versionRequested,
PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
{
rdpChannels* chan_man;
int index;
struct lib_data* llib;
struct channel_data* lchan;
rdpChannel* lrdp_chan;
PCHANNEL_DEF lchan_def;
chan_man = g_init_chan_man;
chan_man->init_handles[chan_man->num_init_handles].chan_man = chan_man;
*ppInitHandle = &chan_man->init_handles[chan_man->num_init_handles];
chan_man->num_init_handles++;
DEBUG_CHANNELS("enter");
if (!chan_man->can_call_init)
{
DEBUG_CHANNELS("error not in entry");
return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
}
if (ppInitHandle == 0)
{
DEBUG_CHANNELS("error bad pphan");
return CHANNEL_RC_BAD_INIT_HANDLE;
}
if (chan_man->num_chans + channelCount >= CHANNEL_MAX_COUNT)
{
DEBUG_CHANNELS("error too many channels");
return CHANNEL_RC_TOO_MANY_CHANNELS;
}
if (pChannel == 0)
{
DEBUG_CHANNELS("error bad pchan");
return CHANNEL_RC_BAD_CHANNEL;
}
if (chan_man->is_connected)
{
DEBUG_CHANNELS("error already connected");
return CHANNEL_RC_ALREADY_CONNECTED;
}
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
{
DEBUG_CHANNELS("warning version");
}
for (index = 0; index < channelCount; index++)
{
lchan_def = pChannel + index;
if (freerdp_channels_find_channel_data_by_name(chan_man, lchan_def->name, 0) != 0)
{
DEBUG_CHANNELS("error channel already used");
return CHANNEL_RC_BAD_CHANNEL;
}
}
llib = chan_man->libs + chan_man->num_libs;
llib->init_event_proc = pChannelInitEventProc;
llib->init_handle = *ppInitHandle;
chan_man->num_libs++;
for (index = 0; index < channelCount; index++)
{
lchan_def = pChannel + index;
lchan = chan_man->chans + chan_man->num_chans;
freerdp_mutex_lock(g_mutex_list);
lchan->open_handle = g_open_handle_sequence++;
freerdp_mutex_unlock(g_mutex_list);
lchan->flags = 1; /* init */
strncpy(lchan->name, lchan_def->name, CHANNEL_NAME_LEN);
lchan->options = lchan_def->options;
if (chan_man->settings->num_channels < 16)
{
lrdp_chan = chan_man->settings->channels + chan_man->settings->num_channels;
strncpy(lrdp_chan->name, lchan_def->name, 7);
lrdp_chan->options = lchan_def->options;
chan_man->settings->num_channels++;
}
else
{
DEBUG_CHANNELS("warning more than 16 channels");
}
chan_man->num_chans++;
}
return CHANNEL_RC_OK;
}
/**
* must be called by same thread that calls freerdp_chanman_load_plugin
* according to MS docs
* only called from main thread
*/
static UINT32 FREERDP_CC MyVirtualChannelInit(void** ppInitHandle, PCHANNEL_DEF pChannel,
int channelCount, UINT32 versionRequested, PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
{
int index;
rdpChannels* channels;
struct lib_data* llib;
rdpChannel* lrdp_channel;
PCHANNEL_DEF lchannel_def;
struct channel_data* lchannel_data;
if (ppInitHandle == NULL)
{
DEBUG_CHANNELS("error bad init handle");
return CHANNEL_RC_BAD_INIT_HANDLE;
}
channels = g_init_channels;
channels->init_handles[channels->num_init_handles].channels = channels;
*ppInitHandle = &channels->init_handles[channels->num_init_handles];
channels->num_init_handles++;
DEBUG_CHANNELS("enter");
if (!channels->can_call_init)
{
DEBUG_CHANNELS("error not in entry");
return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
}
if (channels->num_channels_data + channelCount >= CHANNEL_MAX_COUNT)
{
DEBUG_CHANNELS("error too many channels");
return CHANNEL_RC_TOO_MANY_CHANNELS;
}
if (pChannel == 0)
{
DEBUG_CHANNELS("error bad channel");
return CHANNEL_RC_BAD_CHANNEL;
}
if (channels->is_connected)
{
DEBUG_CHANNELS("error already connected");
return CHANNEL_RC_ALREADY_CONNECTED;
}
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
{
DEBUG_CHANNELS("warning version");
}
for (index = 0; index < channelCount; index++)
{
lchannel_def = pChannel + index;
if (freerdp_channels_find_channel_data_by_name(channels, lchannel_def->name, 0) != 0)
{
DEBUG_CHANNELS("error channel already used");
return CHANNEL_RC_BAD_CHANNEL;
}
}
llib = channels->libs_data + channels->num_libs_data;
llib->init_event_proc = pChannelInitEventProc;
llib->init_handle = *ppInitHandle;
channels->num_libs_data++;
for (index = 0; index < channelCount; index++)
{
lchannel_def = pChannel + index;
lchannel_data = channels->channels_data + channels->num_channels_data;
WaitForSingleObject(g_mutex_list, INFINITE);
lchannel_data->open_handle = g_open_handle_sequence++;
ReleaseMutex(g_mutex_list);
lchannel_data->flags = 1; /* init */
strncpy(lchannel_data->name, lchannel_def->name, CHANNEL_NAME_LEN);
lchannel_data->options = lchannel_def->options;
if (channels->settings->ChannelCount < 16)
{
lrdp_channel = channels->settings->ChannelDefArray + channels->settings->ChannelCount;
strncpy(lrdp_channel->Name, lchannel_def->name, 7);
lrdp_channel->options = lchannel_def->options;
channels->settings->ChannelCount++;
}
else
{
DEBUG_CHANNELS("warning more than 16 channels");
}
channels->num_channels_data++;
}
return CHANNEL_RC_OK;
}
/**
* must be called by same thread that calls freerdp_chanman_load_plugin
* according to MS docs
* only called from main thread
*/
static UINT32 FREERDP_CC MyVirtualChannelInit(void** ppInitHandle, PCHANNEL_DEF pChannel,
int channelCount, UINT32 versionRequested, PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
{
int index;
rdpChannel* channel;
rdpChannels* channels;
rdpLibraryData* llib;
PCHANNEL_DEF lchannel_def;
rdpChannelData* lchannel_data;
if (!ppInitHandle)
{
DEBUG_CHANNELS("error bad init handle");
return CHANNEL_RC_BAD_INIT_HANDLE;
}
channels = g_init_channels;
channels->initHandleList[channels->initHandleCount].channels = channels;
*ppInitHandle = &channels->initHandleList[channels->initHandleCount];
channels->initHandleCount++;
DEBUG_CHANNELS("enter");
if (!channels->can_call_init)
{
DEBUG_CHANNELS("error not in entry");
return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
}
if (channels->channelDataCount + channelCount >= CHANNEL_MAX_COUNT)
{
DEBUG_CHANNELS("error too many channels");
return CHANNEL_RC_TOO_MANY_CHANNELS;
}
if (!pChannel)
{
DEBUG_CHANNELS("error bad channel");
return CHANNEL_RC_BAD_CHANNEL;
}
if (channels->is_connected)
{
DEBUG_CHANNELS("error already connected");
return CHANNEL_RC_ALREADY_CONNECTED;
}
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
{
DEBUG_CHANNELS("warning version");
}
for (index = 0; index < channelCount; index++)
{
lchannel_def = &pChannel[index];
if (freerdp_channels_find_channel_data_by_name(channels, lchannel_def->name, 0) != 0)
{
DEBUG_CHANNELS("error channel already used");
return CHANNEL_RC_BAD_CHANNEL;
}
}
llib = &channels->libraryDataList[channels->libraryDataCount];
llib->init_event_proc = pChannelInitEventProc;
llib->init_handle = *ppInitHandle;
channels->libraryDataCount++;
for (index = 0; index < channelCount; index++)
{
lchannel_def = &pChannel[index];
lchannel_data = &channels->channelDataList[channels->channelDataCount];
lchannel_data->open_handle = g_open_handle_sequence++;
lchannel_data->flags = 1; /* init */
strncpy(lchannel_data->name, lchannel_def->name, CHANNEL_NAME_LEN);
lchannel_data->options = lchannel_def->options;
if (channels->settings->ChannelCount < 16)
{
channel = channels->settings->ChannelDefArray + channels->settings->ChannelCount;
strncpy(channel->Name, lchannel_def->name, 7);
channel->options = lchannel_def->options;
channels->settings->ChannelCount++;
}
else
{
DEBUG_CHANNELS("warning more than 16 channels");
}
channels->channelDataCount++;
}
return CHANNEL_RC_OK;
}
