/**
* Send a plugin-defined event to the plugin.
* called only from main thread
* @param chan_man the channel manager instance
* @param event an event object created by freerdp_event_new()
*/
FREERDP_API int freerdp_chanman_send_event(rdpChanMan* chan_man, RDP_EVENT* event)
{
struct chan_data* lchan_data;
int index;
const char* name;
name = event_class_to_name_table[event->event_class];
if (name == NULL)
{
DEBUG_CHANMAN("unknown event_class %d", event->event_class);
return 1;
}
lchan_data = freerdp_chanman_find_chan_data_by_name(chan_man, name, &index);
if (lchan_data == NULL)
{
DEBUG_CHANMAN("could not find channel name %s", name);
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_chanman_pre_connect(rdpChanMan* chan_man, freerdp* instance)
{
int index;
struct lib_data* llib;
CHANNEL_DEF lchannel_def;
void* dummy;
DEBUG_CHANMAN("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_chanman_find_chan_data_by_name(chan_man, "rdpsnd", 0) != 0 &&
freerdp_chanman_find_chan_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_CHANMAN("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;
}
/**
* Send a plugin-defined event to the plugin.
* called only from main thread
* @param chan_man the channel manager instance
* @param name the static virtual channel name, such as 'cliprdr'
* @param event an event object created by freerdp_event_new()
*/
FREERDP_API int freerdp_chanman_send_event(rdpChanMan* chan_man, const char* name, FRDP_EVENT* event)
{
struct chan_data* lchan_data;
int index;
lchan_data = freerdp_chanman_find_chan_data_by_name(chan_man, name, &index);
if (lchan_data == NULL)
{
DEBUG_CHANMAN("could not find channel name %s", name);
return 1;
}
if (lchan_data->open_event_proc != NULL)
{
lchan_data->open_event_proc(lchan_data->open_handle,
CHANNEL_EVENT_USER,
event, sizeof(FRDP_EVENT), sizeof(FRDP_EVENT), 0);
}
return 0;
}
/* can be called from any thread
thread safe because no 2 threads can have the same channel name registered */
static uint32 VCHAN_CC
MyVirtualChannelOpen(void * pInitHandle, uint32 * pOpenHandle,
char * pChannelName, PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
{
rdpChanMan * chan_man;
int index;
struct chan_data * lchan;
DEBUG_CHANMAN("MyVirtualChannelOpen:");
chan_man = ((rdpInitHandle *) pInitHandle)->chan_man;
if (pOpenHandle == 0)
{
DEBUG_CHANMAN("MyVirtualChannelOpen: error bad chanhan");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (pChannelOpenEventProc == 0)
{
DEBUG_CHANMAN("MyVirtualChannelOpen: error bad proc");
return CHANNEL_RC_BAD_PROC;
}
if (!chan_man->is_connected)
{
DEBUG_CHANMAN("MyVirtualChannelOpen: error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
lchan = freerdp_chanman_find_chan_data_by_name(chan_man, pChannelName, &index);
if (lchan == 0)
{
DEBUG_CHANMAN("MyVirtualChannelOpen: error chan name");
return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
}
if (lchan->flags == 2)
{
DEBUG_CHANMAN("MyVirtualChannelOpen: error chan already open\n");
return CHANNEL_RC_ALREADY_OPEN;
}
lchan->flags = 2; /* open */
lchan->open_event_proc = pChannelOpenEventProc;
*pOpenHandle = lchan->open_handle;
return CHANNEL_RC_OK;
}
/* data comming from the server to the client
called only from main thread */
int
freerdp_chanman_data(rdpInst * inst, int chan_id, char * data, int data_size,
int flags, int total_size)
{
rdpChanMan * chan_man;
struct rdp_chan * lrdp_chan;
struct chan_data * lchan_data;
int index;
chan_man = freerdp_chanman_find_by_rdp_inst(inst);
if (chan_man == 0)
{
DEBUG_CHANMAN("freerdp_chanman_data: could not find channel manager");
return 1;
}
lrdp_chan = freerdp_chanman_find_rdp_chan_by_id(chan_man, inst->settings,
chan_id, &index);
if (lrdp_chan == 0)
{
DEBUG_CHANMAN("freerdp_chanman_data: could not find channel id");
return 1;
}
lchan_data = freerdp_chanman_find_chan_data_by_name(chan_man, lrdp_chan->name,
&index);
if (lchan_data == 0)
{
DEBUG_CHANMAN("freerdp_chanman_data: could not find channel name");
return 1;
}
if (lchan_data->open_event_proc != 0)
{
lchan_data->open_event_proc(lchan_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)
{
rdpChanMan* chan_man;
int index;
struct lib_data* llib;
struct chan_data* lchan;
rdpChan* 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_CHANMAN("enter");
if (!chan_man->can_call_init)
{
DEBUG_CHANMAN("error not in entry");
return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
}
if (ppInitHandle == 0)
{
DEBUG_CHANMAN("error bad pphan");
return CHANNEL_RC_BAD_INIT_HANDLE;
}
if (chan_man->num_chans + channelCount >= CHANNEL_MAX_COUNT)
{
DEBUG_CHANMAN("error too many channels");
return CHANNEL_RC_TOO_MANY_CHANNELS;
}
if (pChannel == 0)
{
DEBUG_CHANMAN("error bad pchan");
return CHANNEL_RC_BAD_CHANNEL;
}
if (chan_man->is_connected)
{
DEBUG_CHANMAN("error already connected");
return CHANNEL_RC_ALREADY_CONNECTED;
}
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
{
DEBUG_CHANMAN("warning version");
}
for (index = 0; index < channelCount; index++)
{
lchan_def = pChannel + index;
if (freerdp_chanman_find_chan_data_by_name(chan_man, lchan_def->name, 0) != 0)
{
DEBUG_CHANMAN("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_CHANMAN("warning more than 16 channels");
}
chan_man->num_chans++;
}
return CHANNEL_RC_OK;
}
