static void svc_plugin_process_data_in(rdpSvcPlugin* plugin)
{
svc_data_in_item* item;
while (1)
{
/* terminate signal */
if (freerdp_thread_is_stopped(plugin->priv->thread))
break;
freerdp_thread_lock(plugin->priv->thread);
item = list_dequeue(plugin->priv->data_in_list);
freerdp_thread_unlock(plugin->priv->thread);
if (item != NULL)
{
/* the ownership of the data is passed to the callback */
if (item->data_in)
IFCALL(plugin->receive_callback, plugin, item->data_in);
if (item->event_in)
IFCALL(plugin->event_callback, plugin, item->event_in);
xfree(item);
}
else
break;
}
}
static void printer_irp_request(DEVICE* device, IRP* irp) {
PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*) device;
freerdp_thread_lock(printer_dev->thread);
list_enqueue(printer_dev->irp_list, irp);
freerdp_thread_unlock(printer_dev->thread);
freerdp_thread_signal(printer_dev->thread);
}
static void serial_irp_request(DEVICE* device, IRP* irp)
{
SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
freerdp_thread_lock(serial->thread);
list_enqueue(serial->irp_list, irp);
freerdp_thread_unlock(serial->thread);
freerdp_thread_signal(serial->thread);
}
static void parallel_irp_request(DEVICE* device, IRP* irp)
{
PARALLEL_DEVICE* parallel = (PARALLEL_DEVICE*) device;
freerdp_thread_lock(parallel->thread);
list_enqueue(parallel->irp_list, irp);
freerdp_thread_unlock(parallel->thread);
freerdp_thread_signal(parallel->thread);
}
static void svc_plugin_process_event(rdpSvcPlugin* plugin, RDP_EVENT* event_in)
{
svc_data_in_item* item;
item = xnew(svc_data_in_item);
item->event_in = event_in;
freerdp_thread_lock(plugin->priv->thread);
list_enqueue(plugin->priv->data_in_list, item);
freerdp_thread_unlock(plugin->priv->thread);
freerdp_thread_signal(plugin->priv->thread);
}
static void
scard_irp_request(DEVICE* device, IRP* irp)
{
COMPLETIONIDINFO* CompletionIdInfo;
SCARD_DEVICE* scard = (SCARD_DEVICE*)device;
/* Begin TS Client defect workaround. */
CompletionIdInfo= xnew(COMPLETIONIDINFO);
CompletionIdInfo->ID = irp->CompletionId;/* "duplicate" member is set
* to false by "xnew()"
*/
freerdp_mutex_lock(scard->CompletionIdsMutex);
scard_mark_duplicate_id(scard, irp->CompletionId);
list_enqueue(scard->CompletionIds, CompletionIdInfo);
freerdp_mutex_unlock(scard->CompletionIdsMutex);
irp->Complete = scard_irp_complete; /* Overwrite the previous
* assignment made in
* "irp_new()".
*/
/* End TS Client defect workaround. */
if (irp->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
scard_async_op(irp))
{
/*
* certain potentially long running operations
* get their own thread
* TODO: revise this mechanism.. maybe worker pool
*/
struct scard_irp_thread_args *args = xmalloc(sizeof(struct scard_irp_thread_args));
args->thread = freerdp_thread_new();
args->scard = scard;
args->irp = irp;
freerdp_thread_start(args->thread, scard_process_irp_thread_func, args);
return;
}
freerdp_thread_lock(scard->thread);
list_enqueue(scard->irp_list, irp);
freerdp_thread_unlock(scard->thread);
freerdp_thread_signal(scard->thread);
}
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
uint32 totalLength, uint32 dataFlags)
{
STREAM* data_in;
svc_data_in_item* item;
if ( (dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
{
/* According to MS-RDPBCGR 2.2.6.1, "All virtual channel traffic MUST be suspended.
This flag is only valid in server-to-client virtual channel traffic. It MUST be
ignored in client-to-server data." Thus it would be best practice to cease data
transmission. However, simply returing here avoids a crash. */
return;
}
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (plugin->priv->data_in != NULL)
stream_free(plugin->priv->data_in);
plugin->priv->data_in = stream_new(totalLength);
}
data_in = plugin->priv->data_in;
stream_check_size(data_in, (int) dataLength);
stream_write(data_in, pData, dataLength);
if (dataFlags & CHANNEL_FLAG_LAST)
{
if (stream_get_size(data_in) != stream_get_length(data_in))
{
printf("svc_plugin_process_received: read error\n");
}
plugin->priv->data_in = NULL;
stream_set_pos(data_in, 0);
item = xnew(svc_data_in_item);
item->data_in = data_in;
freerdp_thread_lock(plugin->priv->thread);
list_enqueue(plugin->priv->data_in_list, item);
freerdp_thread_unlock(plugin->priv->thread);
freerdp_thread_signal(plugin->priv->thread);
}
}
static void printer_process_irp_list(PRINTER_DEVICE* printer_dev) {
IRP* irp;
while (1) {
if (freerdp_thread_is_stopped(printer_dev->thread))
break;
freerdp_thread_lock(printer_dev->thread);
irp = (IRP*) list_dequeue(printer_dev->irp_list);
freerdp_thread_unlock(printer_dev->thread);
if (irp == NULL)
break;
printer_process_irp(printer_dev, irp);
}
}
static void
scard_process_irp_list(SCARD_DEVICE* scard)
{
IRP *irp;
while (!freerdp_thread_is_stopped(scard->thread))
{
freerdp_thread_lock(scard->thread);
irp = (IRP *) list_dequeue(scard->irp_list);
freerdp_thread_unlock(scard->thread);
if (irp == NULL)
break;
scard_process_irp(scard, irp);
}
}
static void serial_process_irp_list(SERIAL_DEVICE* serial)
{
IRP* irp;
while (1)
{
if (freerdp_thread_is_stopped(serial->thread))
break;
freerdp_thread_lock(serial->thread);
irp = (IRP*)list_dequeue(serial->irp_list);
freerdp_thread_unlock(serial->thread);
if (irp == NULL)
break;
serial_process_irp(serial, irp);
}
}
static void parallel_process_irp_list(PARALLEL_DEVICE* parallel)
{
IRP* irp;
while (1)
{
if (freerdp_thread_is_stopped(parallel->thread))
break;
freerdp_thread_lock(parallel->thread);
irp = (IRP*) list_dequeue(parallel->irp_list);
freerdp_thread_unlock(parallel->thread);
if (irp == NULL)
break;
parallel_process_irp(parallel, irp);
}
}
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
uint32 totalLength, uint32 dataFlags)
{
STREAM* data_in;
svc_data_in_item* item;
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (plugin->priv->data_in != NULL)
stream_free(plugin->priv->data_in);
plugin->priv->data_in = stream_new(totalLength);
}
data_in = plugin->priv->data_in;
stream_check_size(data_in, (int) dataLength);
stream_write(data_in, pData, dataLength);
if (dataFlags & CHANNEL_FLAG_LAST)
{
if (stream_get_size(data_in) != stream_get_length(data_in))
{
printf("svc_plugin_process_received: read error\n");
}
plugin->priv->data_in = NULL;
stream_set_pos(data_in, 0);
item = xnew(svc_data_in_item);
item->data_in = data_in;
freerdp_thread_lock(plugin->priv->thread);
list_enqueue(plugin->priv->data_in_list, item);
freerdp_thread_unlock(plugin->priv->thread);
freerdp_thread_signal(plugin->priv->thread);
}
}