/* can be called from any thread */
static UINT32 FREERDP_CC MyVirtualChannelWrite(UINT32 openHandle, void* pData, UINT32 dataLength, void* pUserData)
{
int index;
SYNC_DATA* item;
rdpChannels* channels;
struct channel_data* lchannel_data;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad channel handle");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (pData == 0)
{
DEBUG_CHANNELS("error bad pData");
return CHANNEL_RC_NULL_DATA;
}
if (dataLength == 0)
{
DEBUG_CHANNELS("error bad dataLength");
return CHANNEL_RC_ZERO_LENGTH;
}
lchannel_data = channels->channels_data + index;
if (lchannel_data->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
item = (SYNC_DATA*) _aligned_malloc(sizeof(SYNC_DATA), MEMORY_ALLOCATION_ALIGNMENT);
item->Data = pData;
item->DataLength = dataLength;
item->UserData = pUserData;
item->Index = index;
InterlockedPushEntrySList(channels->pSyncDataList, &(item->ItemEntry));
/* set the event */
SetEvent(channels->signal);
return CHANNEL_RC_OK;
}
/**
* can be called from any thread
* thread safe because no 2 threads can have the same openHandle
*/
static UINT32 FREERDP_CC MyVirtualChannelClose(UINT32 openHandle)
{
int index;
rdpChannels* channels;
struct channel_data* lchannel_data;
DEBUG_CHANNELS("enter");
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad channels");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
lchannel_data = channels->channels_data + index;
if (lchannel_data->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
lchannel_data->flags = 0;
return CHANNEL_RC_OK;
}
/* can be called from any thread */
static UINT32 FREERDP_CC MyVirtualChannelWrite(UINT32 openHandle, void* pData, UINT32 dataLength, void* pUserData)
{
int index;
CHANNEL_OPEN_EVENT* item;
rdpChannels* channels;
rdpChannelData* lchannel_data;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad channel handle");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (!pData)
{
DEBUG_CHANNELS("error bad pData");
return CHANNEL_RC_NULL_DATA;
}
if (!dataLength)
{
DEBUG_CHANNELS("error bad dataLength");
return CHANNEL_RC_ZERO_LENGTH;
}
lchannel_data = &channels->channelDataList[index];
if (lchannel_data->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
item = (CHANNEL_OPEN_EVENT*) malloc(sizeof(CHANNEL_OPEN_EVENT));
item->Data = pData;
item->DataLength = dataLength;
item->UserData = pUserData;
item->Index = index;
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 0, (void*) item, NULL);
return CHANNEL_RC_OK;
}
/* can be called from any thread */
static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, uint32 dataLength,
void* pUserData)
{
rdpChannels* chan_man;
struct channel_data* lchan;
struct sync_data* item;
int index;
chan_man = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad chanhan");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!chan_man->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (pData == 0)
{
DEBUG_CHANNELS("error bad pData");
return CHANNEL_RC_NULL_DATA;
}
if (dataLength == 0)
{
DEBUG_CHANNELS("error bad dataLength");
return CHANNEL_RC_ZERO_LENGTH;
}
lchan = chan_man->chans + index;
if (lchan->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
freerdp_mutex_lock(chan_man->sync_data_mutex); /* lock channels->sync* vars */
if (!chan_man->is_connected)
{
freerdp_mutex_unlock(chan_man->sync_data_mutex);
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
item = xnew(struct sync_data);
item->data = pData;
item->data_length = dataLength;
item->user_data = pUserData;
item->index = index;
list_enqueue(chan_man->sync_data_list, item);
freerdp_mutex_unlock(chan_man->sync_data_mutex);
/* set the event */
wait_obj_set(chan_man->signal);
return CHANNEL_RC_OK;
}
static UINT32 FREERDP_CC MyVirtualChannelEventPush(UINT32 openHandle, wMessage* event)
{
int index;
rdpChannels* channels;
rdpChannelData* lchannel_data;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad channels handle");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (!event)
{
DEBUG_CHANNELS("error bad event");
return CHANNEL_RC_NULL_DATA;
}
lchannel_data = &channels->channelDataList[index];
if (lchannel_data->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
/**
* We really intend to use the In queue for events, but we're pushing on both
* to wake up threads waiting on the out queue. Doing this cleanly would require
* breaking freerdp_pop_event() a bit too early in this refactoring.
*/
MessageQueue_Post(channels->MsgPipe->In, (void*) channels, 1, (void*) event, NULL);
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 1, (void*) event, NULL);
return CHANNEL_RC_OK;
}
static UINT32 FREERDP_CC MyVirtualChannelEventPush(UINT32 openHandle, RDP_EVENT* event)
{
int index;
rdpChannels* channels;
struct channel_data* lchannel_data;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad channels handle");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (event == NULL)
{
DEBUG_CHANNELS("error bad event");
return CHANNEL_RC_NULL_DATA;
}
lchannel_data = channels->channels_data + index;
if (lchannel_data->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
/* lock channels->event */
WaitForSingleObject(channels->event_sem, INFINITE);
if (!channels->is_connected)
{
ReleaseSemaphore(channels->event_sem, 1, NULL);
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
channels->event = event;
/* set the event */
SetEvent(channels->signal);
return CHANNEL_RC_OK;
}
static uint32 FREERDP_CC MyVirtualChannelEventPush(uint32 openHandle, RDP_EVENT* event)
{
rdpChannels* chan_man;
struct channel_data* lchan;
int index;
chan_man = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
DEBUG_CHANNELS("error bad chanhan");
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!chan_man->is_connected)
{
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
if (event == NULL)
{
DEBUG_CHANNELS("error bad event");
return CHANNEL_RC_NULL_DATA;
}
lchan = chan_man->chans + index;
if (lchan->flags != 2)
{
DEBUG_CHANNELS("error not open");
return CHANNEL_RC_NOT_OPEN;
}
freerdp_sem_wait(chan_man->event_sem); /* lock channels->event */
if (!chan_man->is_connected)
{
freerdp_sem_signal(chan_man->event_sem);
DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED;
}
chan_man->event = event;
/* set the event */
wait_obj_set(chan_man->signal);
return CHANNEL_RC_OK;
}
