static int
do_txrx_work(struct s3c2410_spi *device)
{
dprintf("%s: called\n", __func__);
struct stream_interface *txsi = &device->tx;
struct stream_interface *rxsi = &device->rx;
struct stream_pkt *tx_pkt = stream_get_head(txsi);
struct stream_pkt *rx_pkt = stream_get_head(rxsi);
/*
* tx phase - this triggers the SPI device to push data
* into the rx_data register also
*
* XXX: checks and asserts? - nt
* XXX: I don't even know if stream_pkt make sense for SPI
*/
if (tx_pkt != NULL)
sptdat_set_txdata(tx_pkt->data[tx_pkt->xferred++]);
else
sptdat_set_txdata(0xff); /* write dummy data */
/* rx phase
*
* XXX: see tx phase - nt
*/
if (rx_pkt != NULL)
rx_pkt->data[rx_pkt->xferred++] = sprdat_get_rxdata();
return 0;
}
int credssp_client_authenticate(rdpCredssp* credssp)
{
NTLMSSP* ntlmssp = credssp->ntlmssp;
STREAM* s = stream_new(0);
uint8* negoTokenBuffer = (uint8*) xmalloc(2048);
if (credssp_ntlmssp_client_init(credssp) == 0)
return 0;
/* NTLMSSP NEGOTIATE MESSAGE */
stream_attach(s, negoTokenBuffer, 2048);
ntlmssp_send(ntlmssp, s);
credssp->negoToken.data = stream_get_head(s);
credssp->negoToken.length = stream_get_length(s);
credssp_send(credssp, &credssp->negoToken, NULL, NULL);
/* NTLMSSP CHALLENGE MESSAGE */
if (credssp_recv(credssp, &credssp->negoToken, NULL, NULL) < 0)
return -1;
stream_attach(s, credssp->negoToken.data, credssp->negoToken.length);
ntlmssp_recv(ntlmssp, s);
freerdp_blob_free(&credssp->negoToken);
/* NTLMSSP AUTHENTICATE MESSAGE */
stream_attach(s, negoTokenBuffer, 2048);
ntlmssp_send(ntlmssp, s);
/* The last NTLMSSP message is sent with the encrypted public key */
credssp->negoToken.data = stream_get_head(s);
credssp->negoToken.length = stream_get_length(s);
credssp_encrypt_public_key(credssp, &credssp->pubKeyAuth);
credssp_send(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth);
freerdp_blob_free(&credssp->pubKeyAuth);
/* Encrypted Public Key +1 */
if (credssp_recv(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth) < 0)
return -1;
if (credssp_verify_public_key(credssp, &credssp->pubKeyAuth) == 0)
{
/* Failed to verify server public key echo */
return 0; /* DO NOT SEND CREDENTIALS! */
}
freerdp_blob_free(&credssp->negoToken);
freerdp_blob_free(&credssp->pubKeyAuth);
/* Send encrypted credentials */
credssp_encode_ts_credentials(credssp);
credssp_encrypt_ts_credentials(credssp, &credssp->authInfo);
credssp_send(credssp, NULL, &credssp->authInfo, NULL);
freerdp_blob_free(&credssp->authInfo);
xfree(s);
return 1;
}
static void test_peer_draw_icon(freerdp_peer* client, int x, int y)
{
testPeerContext* context = (testPeerContext*) client->context;
rdpUpdate* update = client->update;
SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command;
RFX_RECT rect;
STREAM* s;
if (client->update->dump_rfx)
return;
if (!client->settings->rfx_codec || !context)
return;
if (context->icon_width < 1 || !context->activated)
return;
rect.x = 0;
rect.y = 0;
rect.width = context->icon_width;
rect.height = context->icon_height;
if (context->icon_x >= 0)
{
s = test_peer_stream_init(context);
rfx_compose_message(context->rfx_context, s,
&rect, 1, context->bg_data, rect.width, rect.height, rect.width * 3);
cmd->destLeft = context->icon_x;
cmd->destTop = context->icon_y;
cmd->destRight = context->icon_x + context->icon_width;
cmd->destBottom = context->icon_y + context->icon_height;
cmd->bpp = 32;
cmd->codecID = client->settings->rfx_codec_id;
cmd->width = context->icon_width;
cmd->height = context->icon_height;
cmd->bitmapDataLength = stream_get_length(s);
cmd->bitmapData = stream_get_head(s);
update->SurfaceBits(update->context, cmd);
}
s = test_peer_stream_init(context);
rfx_compose_message(context->rfx_context, s,
&rect, 1, context->icon_data, rect.width, rect.height, rect.width * 3);
cmd->destLeft = x;
cmd->destTop = y;
cmd->destRight = x + context->icon_width;
cmd->destBottom = y + context->icon_height;
cmd->bpp = 32;
cmd->codecID = client->settings->rfx_codec_id;
cmd->width = context->icon_width;
cmd->height = context->icon_height;
cmd->bitmapDataLength = stream_get_length(s);
cmd->bitmapData = stream_get_head(s);
update->SurfaceBits(update->context, cmd);
context->icon_x = x;
context->icon_y = y;
}
static void* tf_debug_channel_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
UINT32 bytes_returned = 0;
testPeerContext* context = (testPeerContext*) arg;
freerdp_thread* thread = context->debug_channel_thread;
if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == TRUE)
{
fd = *((void**) buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = CreateFileDescriptorEvent(NULL, TRUE, FALSE, ((int) (long) fd));
}
s = stream_new(4096);
WTSVirtualChannelWrite(context->debug_channel, (BYTE*) "test1", 5, NULL);
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
{
if (bytes_returned == 0)
break;
stream_check_size(s, bytes_returned);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
{
/* should not happen */
break;
}
}
stream_set_pos(s, bytes_returned);
printf("got %d bytes\n", bytes_returned);
}
stream_free(s);
freerdp_thread_quit(thread);
return 0;
}
static void* tf_debug_channel_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
uint32 bytes_returned = 0;
testPeerContext* context = (testPeerContext*) arg;
freerdp_thread* thread = context->debug_channel_thread;
if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == true)
{
fd = *((void**)buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = wait_obj_new_with_fd(fd);
}
s = stream_new(4096);
WTSVirtualChannelWrite(context->debug_channel, (uint8*) "test1", 5, NULL);
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
{
if (bytes_returned == 0)
break;
stream_check_size(s, bytes_returned);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
{
/* should not happen */
break;
}
}
stream_set_pos(s, bytes_returned);
printf("got %d bytes\n", bytes_returned);
}
stream_free(s);
freerdp_thread_quit(thread);
return 0;
}
static void
do_xmit_work(struct c8250_serial *device)
{
struct stream_interface *si = &device->tx;
struct stream_pkt *packet = stream_get_head(si);
if (packet == NULL) {
return;
}
assert(packet->data);
while (!tx_ready()) {
thr_write(packet->data[packet->xferred++]);
assert(packet->xferred <= packet->length);
if (packet->xferred == packet->length) {
packet = stream_switch_head(si);
if (packet == NULL) {
break;
}
}
}
ier_set_txie(1);
return;
}
static void audin_server_send_formats(audin_server* audin, STREAM* s)
{
int i;
UINT32 nAvgBytesPerSec;
stream_set_pos(s, 0);
stream_write_BYTE(s, MSG_SNDIN_FORMATS);
stream_write_UINT32(s, audin->context.num_server_formats); /* NumFormats (4 bytes) */
stream_write_UINT32(s, 0); /* cbSizeFormatsPacket (4 bytes), client-to-server only */
for (i = 0; i < audin->context.num_server_formats; i++)
{
nAvgBytesPerSec = audin->context.server_formats[i].nSamplesPerSec *
audin->context.server_formats[i].nChannels *
audin->context.server_formats[i].wBitsPerSample / 8;
stream_check_size(s, 18);
stream_write_UINT16(s, audin->context.server_formats[i].wFormatTag);
stream_write_UINT16(s, audin->context.server_formats[i].nChannels);
stream_write_UINT32(s, audin->context.server_formats[i].nSamplesPerSec);
stream_write_UINT32(s, nAvgBytesPerSec);
stream_write_UINT16(s, audin->context.server_formats[i].nBlockAlign);
stream_write_UINT16(s, audin->context.server_formats[i].wBitsPerSample);
stream_write_UINT16(s, audin->context.server_formats[i].cbSize);
if (audin->context.server_formats[i].cbSize)
{
stream_check_size(s, audin->context.server_formats[i].cbSize);
stream_write(s, audin->context.server_formats[i].data,
audin->context.server_formats[i].cbSize);
}
}
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, BYTE* data, int size, int flags, int total_size)
{
if (flags & CHANNEL_FLAG_FIRST)
{
stream_set_pos(channel->receive_data, 0);
}
stream_check_size(channel->receive_data, size);
stream_write(channel->receive_data, data, size);
if (flags & CHANNEL_FLAG_LAST)
{
if (stream_get_length(channel->receive_data) != total_size)
{
fprintf(stderr, "WTSProcessChannelData: read error\n");
}
if (channel == channel->vcm->drdynvc_channel)
{
wts_read_drdynvc_pdu(channel);
}
else
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), stream_get_length(channel->receive_data));
}
stream_set_pos(channel->receive_data, 0);
}
}
void test_nsc_encode(void)
{
int i;
uint8* rgb_data;
STREAM* enc_stream;
NSC_CONTEXT* context;
rgb_data = (uint8 *) malloc(64 * 64 * 3);
for (i = 0; i < 64; i++)
memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
context = nsc_context_new();
nsc_context_set_cpu_opt(context, CPU_SSE2);
nsc_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
enc_stream = stream_new(65536);
stream_clear(enc_stream);
for (i = 0; i < 30000; i++)
{
stream_set_pos(enc_stream, 0);
nsc_compose_message(context, enc_stream, rgb_data, 64, 64, 64 * 3);
}
/*freerdp_hexdump(stream_get_head(enc_stream), stream_get_length(enc_stream));*/
nsc_process_message(context, 32, 64, 64, stream_get_head(enc_stream), stream_get_length(enc_stream));
/*freerdp_hexdump(context->bmpdata, 64 * 64 * 4);*/
stream_free(enc_stream);
nsc_context_free(context);
}
int rpch_out_read_http_header(rdpRpch* rpch)
{
int status;
int content_length;
rdpTls* tls_out = rpch->tls_out;
rdpRpchHTTP* http_out = rpch->http_out;
STREAM* http_stream;
http_stream = read_http(tls_out, &content_length, false);
if (http_stream == NULL)
{
LLOGLN(0, ("rpch_out_read_http_header: read_http failed"));
return -1;
}
status = 0;
http_out->contentLength = content_length;
http_out->remContentLength = http_out->contentLength;
DEBUG_RPCH("\nRecv HTTP header:\n%s", stream_get_head(http_stream));
stream_free(http_stream);
return status;
}
static void audin_server_send_open(audin_server* audin, STREAM* s)
{
if (audin->context.selected_client_format < 0)
return;
audin->opened = TRUE;
stream_set_pos(s, 0);
stream_write_BYTE(s, MSG_SNDIN_OPEN);
stream_write_UINT32(s, audin->context.frames_per_packet); /* FramesPerPacket (4 bytes) */
stream_write_UINT32(s, audin->context.selected_client_format); /* initialFormat (4 bytes) */
/*
* [MS-RDPEAI] 3.2.5.1.6
* The second format specify the format that SHOULD be used to capture data from
* the actual audio input device.
*/
stream_write_UINT16(s, 1); /* wFormatTag = PCM */
stream_write_UINT16(s, 2); /* nChannels */
stream_write_UINT32(s, 44100); /* nSamplesPerSec */
stream_write_UINT32(s, 44100 * 2 * 2); /* nAvgBytesPerSec */
stream_write_UINT16(s, 4); /* nBlockAlign */
stream_write_UINT16(s, 16); /* wBitsPerSample */
stream_write_UINT16(s, 0); /* cbSize */
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
void cliprdr_process_format_list_event(cliprdrPlugin* cliprdr, RDP_CB_FORMAT_LIST_EVENT* cb_event)
{
int i;
wStream* s;
DEBUG_CLIPRDR("Sending Clipboard Format List");
if (cb_event->raw_format_data)
{
s = cliprdr_packet_new(CB_FORMAT_LIST, 0, cb_event->raw_format_data_size);
stream_write(s, cb_event->raw_format_data, cb_event->raw_format_data_size);
}
else
{
wStream* body = stream_new(0);
for (i = 0; i < cb_event->num_formats; i++)
{
const char* name;
int name_length;
switch (cb_event->formats[i])
{
case CB_FORMAT_HTML:
name = CFSTR_HTML; name_length = sizeof(CFSTR_HTML);
break;
case CB_FORMAT_PNG:
name = CFSTR_PNG; name_length = sizeof(CFSTR_PNG);
break;
case CB_FORMAT_JPEG:
name = CFSTR_JPEG; name_length = sizeof(CFSTR_JPEG);
break;
case CB_FORMAT_GIF:
name = CFSTR_GIF; name_length = sizeof(CFSTR_GIF);
break;
default:
name = "\0\0";
name_length = 2;
break;
}
if (!cliprdr->use_long_format_names)
name_length = 32;
stream_extend(body, stream_get_size(body) + 4 + name_length);
stream_write_UINT32(body, cb_event->formats[i]);
stream_write(body, name, name_length);
}
s = cliprdr_packet_new(CB_FORMAT_LIST, 0, stream_get_size(body));
stream_write(s, stream_get_head(body), stream_get_size(body));
stream_free(body);
}
cliprdr_packet_send(cliprdr, s);
}
BOOL WTSVirtualChannelClose(
/* __in */ void* hChannelHandle)
{
wStream* s;
wts_data_item* item;
WTSVirtualChannelManager* vcm;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
if (channel)
{
vcm = channel->vcm;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
if (channel->index < channel->client->settings->ChannelCount)
channel->client->settings->ChannelDefArray[channel->index].handle = NULL;
}
else
{
WaitForSingleObject(vcm->mutex, INFINITE);
list_remove(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
{
s = stream_new(8);
wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channel_id);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
}
}
if (channel->receive_data)
stream_free(channel->receive_data);
if (channel->receive_event)
CloseHandle(channel->receive_event);
if (channel->receive_queue)
{
while ((item = (wts_data_item*) list_dequeue(channel->receive_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(channel->receive_queue);
}
if (channel->mutex)
CloseHandle(channel->mutex);
free(channel);
}
return TRUE;
}
static void update_send_surface_command(rdpContext* context, STREAM* s)
{
STREAM* update;
rdpRdp* rdp = context->rdp;
update = fastpath_update_pdu_init(rdp->fastpath);
stream_check_size(update, stream_get_length(s));
stream_write(update, stream_get_head(s), stream_get_length(s));
fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update);
}
static void test_peer_draw_background(freerdp_peer* client)
{
int size;
STREAM* s;
RFX_RECT rect;
BYTE* rgb_data;
rdpUpdate* update = client->update;
SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command;
testPeerContext* context = (testPeerContext*) client->context;
if (!client->settings->RemoteFxCodec && !client->settings->NSCodec)
return;
test_peer_begin_frame(client);
s = test_peer_stream_init(context);
rect.x = 0;
rect.y = 0;
rect.width = client->settings->DesktopWidth;
rect.height = client->settings->DesktopHeight;
size = rect.width * rect.height * 3;
rgb_data = malloc(size);
memset(rgb_data, 0xA0, size);
if (client->settings->RemoteFxCodec)
{
rfx_compose_message(context->rfx_context, s,
&rect, 1, rgb_data, rect.width, rect.height, rect.width * 3);
cmd->codecID = client->settings->RemoteFxCodecId;
}
else
{
nsc_compose_message(context->nsc_context, s,
rgb_data, rect.width, rect.height, rect.width * 3);
cmd->codecID = client->settings->NSCodecId;
}
cmd->destLeft = 0;
cmd->destTop = 0;
cmd->destRight = rect.width;
cmd->destBottom = rect.height;
cmd->bpp = 32;
cmd->width = rect.width;
cmd->height = rect.height;
cmd->bitmapDataLength = stream_get_length(s);
cmd->bitmapData = stream_get_head(s);
update->SurfaceBits(update->context, cmd);
free(rgb_data);
test_peer_end_frame(client);
}
/* header is not removed from data in this function */
static void rdpsnd_process_message_wave(rdpsndPlugin* rdpsnd, STREAM* data_in)
{
uint16 wTimeStamp;
uint32 delay_ms;
uint32 process_ms;
struct data_out_item* item;
rdpsnd->expectingWave = 0;
memcpy(stream_get_head(data_in), rdpsnd->waveData, 4);
if (stream_get_size(data_in) != rdpsnd->waveDataSize)
{
DEBUG_WARN("size error");
return;
}
if (rdpsnd->device)
IFCALL(rdpsnd->device->Play, rdpsnd->device, stream_get_head(data_in), stream_get_size(data_in));
process_ms = get_mstime() - rdpsnd->wave_timestamp;
delay_ms = 250;
wTimeStamp = rdpsnd->wTimeStamp + delay_ms;
DEBUG_SVC("data_size %d delay_ms %u process_ms %u",
stream_get_size(data_in), delay_ms, process_ms);
item = xnew(struct data_out_item);
item->data_out = stream_new(8);
stream_write_uint8(item->data_out, SNDC_WAVECONFIRM);
stream_write_uint8(item->data_out, 0);
stream_write_uint16(item->data_out, 4);
stream_write_uint16(item->data_out, wTimeStamp);
stream_write_uint8(item->data_out, rdpsnd->cBlockNo); /* cConfirmedBlockNo */
stream_write_uint8(item->data_out, 0); /* bPad */
item->out_timestamp = rdpsnd->wave_timestamp + delay_ms;
list_enqueue(rdpsnd->data_out_list, item);
rdpsnd->plugin.interval_ms = 10;
}
boolean WTSVirtualChannelClose(
/* __in */ void* hChannelHandle)
{
STREAM* s;
wts_data_item* item;
WTSVirtualChannelManager* vcm;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
if (channel)
{
vcm = channel->vcm;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
if (channel->index < channel->client->settings->num_channels)
channel->client->settings->channels[channel->index].handle = NULL;
}
else
{
freerdp_mutex_lock(vcm->mutex);
list_remove(vcm->dvc_channel_list, channel);
freerdp_mutex_unlock(vcm->mutex);
if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
{
s = stream_new(8);
wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channel_id);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
}
}
if (channel->receive_data)
stream_free(channel->receive_data);
if (channel->receive_event)
wait_obj_free(channel->receive_event);
if (channel->receive_queue)
{
while ((item = (wts_data_item*) list_dequeue(channel->receive_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(channel->receive_queue);
}
if (channel->mutex)
freerdp_mutex_free(channel->mutex);
xfree(channel);
}
return true;
}
void wf_update_encode(wfInfo* wfi)
{
RFX_RECT rect;
long height, width;
BYTE* pDataBits = NULL;
int stride;
SURFACE_BITS_COMMAND* cmd;
wf_info_find_invalid_region(wfi);
cmd = &wfi->cmd;
stream_set_pos(wfi->s, 0);
wf_info_getScreenData(wfi, &width, &height, &pDataBits, &stride);
rect.x = 0;
rect.y = 0;
rect.width = (UINT16) width;
rect.height = (UINT16) height;
//printf("x:%d y:%d w:%d h:%d\n", wfi->invalid.left, wfi->invalid.top, width, height);
stream_clear(wfi->s);
rfx_compose_message(wfi->rfx_context, wfi->s, &rect, 1,
pDataBits, width, height, stride);
wfi->frame_idx = wfi->rfx_context->frame_idx;
cmd->destLeft = wfi->invalid.left;
cmd->destTop = wfi->invalid.top;
cmd->destRight = wfi->invalid.left + width;
cmd->destBottom = wfi->invalid.top + height;
cmd->bpp = 32;
cmd->codecID = 3;
cmd->width = width;
cmd->height = height;
cmd->bitmapDataLength = stream_get_length(wfi->s);
cmd->bitmapData = stream_get_head(wfi->s);
}
void wf_update_encode(wfInfo* wfi)
{
long offset;
RFX_RECT rect;
long height, width;
GETCHANGESBUF* changes;
SURFACE_BITS_COMMAND* cmd;
wf_info_find_invalid_region(wfi);
cmd = &wfi->cmd;
changes = (GETCHANGESBUF*) wfi->changeBuffer;
width = (wfi->invalid.right - wfi->invalid.left) + 1;
height = (wfi->invalid.bottom - wfi->invalid.top) + 1;
stream_clear(wfi->s);
stream_set_pos(wfi->s, 0);
rect.x = 0;
rect.y = 0;
rect.width = (uint16) width;
rect.height = (uint16) height;
offset = (4 * wfi->invalid.left) + (wfi->invalid.top * wfi->width * 4);
rfx_compose_message(wfi->rfx_context, wfi->s, &rect, 1,
((uint8*) (changes->Userbuffer)) + offset, width, height, wfi->width * 4);
cmd->destLeft = wfi->invalid.left;
cmd->destTop = wfi->invalid.top;
cmd->destRight = wfi->invalid.left + width;
cmd->destBottom = wfi->invalid.top + height;
cmd->bpp = 32;
cmd->codecID = 3;
cmd->width = width;
cmd->height = height;
cmd->bitmapDataLength = stream_get_length(wfi->s);
cmd->bitmapData = stream_get_head(wfi->s);
}
static void test_peer_draw_background(freerdp_peer* client)
{
testPeerContext* context = (testPeerContext*) client->context;
rdpUpdate* update = client->update;
SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command;
STREAM* s;
RFX_RECT rect;
uint8* rgb_data;
int size;
if (!client->settings->rfx_codec)
return;
s = test_peer_stream_init(context);
rect.x = 0;
rect.y = 0;
rect.width = client->settings->width;
rect.height = client->settings->height;
size = rect.width * rect.height * 3;
rgb_data = xmalloc(size);
memset(rgb_data, 0xA0, size);
rfx_compose_message(context->rfx_context, s,
&rect, 1, rgb_data, rect.width, rect.height, rect.width * 3);
cmd->destLeft = 0;
cmd->destTop = 0;
cmd->destRight = rect.width;
cmd->destBottom = rect.height;
cmd->bpp = 32;
cmd->codecID = client->settings->rfx_codec_id;
cmd->width = rect.width;
cmd->height = rect.height;
cmd->bitmapDataLength = stream_get_length(s);
cmd->bitmapData = stream_get_head(s);
update->SurfaceBits(update->context, cmd);
xfree(rgb_data);
}
static void xf_cliprdr_process_dib(clipboardContext* cb, uint8* data, int size)
{
STREAM* s;
uint16 bpp;
uint32 offset;
uint32 ncolors;
/* size should be at least sizeof(BITMAPINFOHEADER) */
if (size < 40)
{
DEBUG_X11("dib size %d too short", size);
return;
}
s = stream_new(0);
stream_attach(s, data, size);
stream_seek(s, 14);
stream_read_uint16(s, bpp);
stream_read_uint32(s, ncolors);
offset = 14 + 40 + (bpp <= 8 ? (ncolors == 0 ? (1 << bpp) : ncolors) * 4 : 0);
stream_detach(s);
stream_free(s);
DEBUG_X11("offset=%d bpp=%d ncolors=%d",
offset, bpp, ncolors);
s = stream_new(14 + size);
stream_write_uint8(s, 'B');
stream_write_uint8(s, 'M');
stream_write_uint32(s, 14 + size);
stream_write_uint32(s, 0);
stream_write_uint32(s, offset);
stream_write(s, data, size);
cb->data = stream_get_head(s);
cb->data_length = stream_get_length(s);
stream_detach(s);
stream_free(s);
}
static void wts_read_drdynvc_data(rdpPeerChannel* channel, STREAM* s, uint32 length)
{
if (channel->dvc_total_length > 0)
{
if (stream_get_length(channel->receive_data) + length > channel->dvc_total_length)
{
channel->dvc_total_length = 0;
printf("wts_read_drdynvc_data: incorrect fragment data, discarded.\n");
return;
}
stream_write(channel->receive_data, stream_get_tail(s), length);
if (stream_get_length(channel->receive_data) >= (int) channel->dvc_total_length)
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), channel->dvc_total_length);
channel->dvc_total_length = 0;
}
}
else
{
wts_queue_receive_data(channel, stream_get_tail(s), length);
}
}
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, uint8* data, int size, int flags, int total_size)
{
wts_data_item* item;
if (flags & CHANNEL_FLAG_FIRST)
{
stream_set_pos(channel->receive_data, 0);
}
stream_check_size(channel->receive_data, size);
stream_write(channel->receive_data, data, size);
if (flags & CHANNEL_FLAG_LAST)
{
if (stream_get_length(channel->receive_data) != total_size)
{
printf("WTSProcessChannelData: read error\n");
}
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_DVC)
{
/* TODO: Receive DVC channel data */
}
else
{
item = xnew(wts_data_item);
item->length = stream_get_length(channel->receive_data);
item->buffer = xmalloc(item->length);
memcpy(item->buffer, stream_get_head(channel->receive_data), item->length);
freerdp_mutex_lock(channel->mutex);
list_enqueue(channel->receive_queue, item);
freerdp_mutex_unlock(channel->mutex);
wait_obj_set(channel->receive_event);
}
stream_set_pos(channel->receive_data, 0);
}
}
void tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback,
uint32 message_id, uint64 duration, uint32 data_size)
{
STREAM* s;
int error;
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*) pChannelCallback;
s = stream_new(32);
stream_write_uint32(s, TSMF_INTERFACE_CLIENT_NOTIFICATIONS | STREAM_ID_PROXY);
stream_write_uint32(s, message_id);
stream_write_uint32(s, PLAYBACK_ACK); /* FunctionId */
stream_write_uint32(s, callback->stream_id); /* StreamId */
stream_write_uint64(s, duration); /* DataDuration */
stream_write_uint64(s, data_size); /* cbData */
DEBUG_DVC("response size %d", stream_get_length(s));
error = callback->channel->Write(callback->channel, stream_get_length(s), stream_get_head(s), NULL);
if (error)
{
DEBUG_WARN("response error %d", error);
}
stream_free(s);
}
static int
do_rx_work(struct c8250_serial *device)
{
uint8_t data;
struct stream_interface *si = &device->rx;
struct stream_pkt *packet = stream_get_head(si);
while (rx_ready()) {
data = rbr_get_data();
/* 11 or 0xb is Ctrl-k */
if ((data & 0xff) == 0xb){
L4_KDB_Enter("breakin");
// Dont want to pass the C-k to the client
continue;
}
if(!packet)
continue;
packet->data[packet->xferred] = (data & 0xFF);
packet->xferred++;
while(rx_ready())
rbr_get_data();
if (packet->xferred == packet->length) {
if ((packet = stream_switch_head(si)) == NULL) {
break;
}
}
}
if (packet){
if (packet->xferred)
packet = stream_switch_head(si);
}
return 0;
}
void* WTSVirtualChannelOpenEx(
/* __in */ WTSVirtualChannelManager* vcm,
/* __in */ const char* pVirtualName,
/* __in */ UINT32 flags)
{
int i;
int len;
wStream* s;
rdpPeerChannel* channel;
freerdp_peer* client = vcm->client;
if ((flags & WTS_CHANNEL_OPTION_DYNAMIC) != 0)
{
if (vcm->drdynvc_channel == NULL || vcm->drdynvc_state != DRDYNVC_STATE_READY)
{
DEBUG_DVC("Dynamic virtual channel not ready.");
return NULL;
}
channel = (rdpPeerChannel*) malloc(sizeof(rdpPeerChannel));
ZeroMemory(channel, sizeof(rdpPeerChannel));
channel->vcm = vcm;
channel->client = client;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_DVC;
channel->receive_data = stream_new(client->settings->VirtualChannelChunkSize);
channel->receive_event = CreateEvent(NULL, TRUE, FALSE, NULL);
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
WaitForSingleObject(vcm->mutex, INFINITE);
channel->channel_id = vcm->dvc_channel_id_seq++;
list_enqueue(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
s = stream_new(64);
wts_write_drdynvc_create_request(s, channel->channel_id, pVirtualName);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
DEBUG_DVC("ChannelId %d.%s (total %d)", channel->channel_id, pVirtualName, list_size(vcm->dvc_channel_list));
}
else
{
len = strlen(pVirtualName);
if (len > 8)
return NULL;
for (i = 0; i < client->settings->ChannelCount; i++)
{
if (client->settings->ChannelDefArray[i].joined &&
strncmp(client->settings->ChannelDefArray[i].Name, pVirtualName, len) == 0)
{
break;
}
}
if (i >= client->settings->ChannelCount)
return NULL;
channel = (rdpPeerChannel*) client->settings->ChannelDefArray[i].handle;
if (channel == NULL)
{
channel = (rdpPeerChannel*) malloc(sizeof(rdpPeerChannel));
ZeroMemory(channel, sizeof(rdpPeerChannel));
channel->vcm = vcm;
channel->client = client;
channel->channel_id = client->settings->ChannelDefArray[i].ChannelId;
channel->index = i;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_SVC;
channel->receive_data = stream_new(client->settings->VirtualChannelChunkSize);
channel->receive_event = CreateEvent(NULL, TRUE, FALSE, NULL);
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
client->settings->ChannelDefArray[i].handle = channel;
}
}
return channel;
}
int transport_check_fds(rdpTransport* transport)
{
int pos;
int status;
uint16 length;
STREAM* received;
wait_obj_clear(transport->recv_event);
status = transport_read_nonblocking(transport);
if (status < 0)
return status;
while ((pos = stream_get_pos(transport->recv_buffer)) > 0)
{
stream_set_pos(transport->recv_buffer, 0);
if (tpkt_verify_header(transport->recv_buffer)) /* TPKT */
{
/* Ensure the TPKT header is available. */
if (pos <= 4)
{
stream_set_pos(transport->recv_buffer, pos);
return 0;
}
length = tpkt_read_header(transport->recv_buffer);
}
else /* Fast Path */
{
/* Ensure the Fast Path header is available. */
if (pos <= 2)
{
stream_set_pos(transport->recv_buffer, pos);
return 0;
}
length = fastpath_read_header(NULL, transport->recv_buffer);
}
if (length == 0)
{
printf("transport_check_fds: protocol error, not a TPKT or Fast Path header.\n");
freerdp_hexdump(stream_get_head(transport->recv_buffer), pos);
return -1;
}
if (pos < length)
{
stream_set_pos(transport->recv_buffer, pos);
return 0; /* Packet is not yet completely received. */
}
/*
* A complete packet has been received. In case there are trailing data
* for the next packet, we copy it to the new receive buffer.
*/
received = transport->recv_buffer;
transport->recv_buffer = stream_new(BUFFER_SIZE);
if (pos > length)
{
stream_set_pos(received, length);
stream_check_size(transport->recv_buffer, pos - length);
stream_copy(transport->recv_buffer, received, pos - length);
}
stream_set_pos(received, length);
stream_seal(received);
stream_set_pos(received, 0);
if (transport->recv_callback(transport, received, transport->recv_extra) == False)
status = -1;
stream_free(received);
if (status < 0)
return status;
}
return 0;
}
int transport_check_fds(rdpTransport** ptransport)
{
int pos;
int status;
uint16 length;
STREAM* received;
rdpTransport* transport = *ptransport;
wait_obj_clear(transport->recv_event);
status = transport_read_nonblocking(transport);
if (status < 0)
return status;
while ((pos = stream_get_pos(transport->recv_buffer)) > 0)
{
stream_set_pos(transport->recv_buffer, 0);
if (tpkt_verify_header(transport->recv_buffer)) /* TPKT */
{
/* Ensure the TPKT header is available. */
if (pos <= 4)
{
stream_set_pos(transport->recv_buffer, pos);
return 0;
}
length = tpkt_read_header(transport->recv_buffer);
}
else /* Fast Path */
{
/* Ensure the Fast Path header is available. */
if (pos <= 2)
{
stream_set_pos(transport->recv_buffer, pos);
return 0;
}
/* Fastpath header can be two or three bytes long. */
length = fastpath_header_length(transport->recv_buffer);
if (pos < length)
{
stream_set_pos(transport->recv_buffer, pos);
return 0;
}
length = fastpath_read_header(NULL, transport->recv_buffer);
}
if (length == 0)
{
printf("transport_check_fds: protocol error, not a TPKT or Fast Path header.\n");
freerdp_hexdump(stream_get_head(transport->recv_buffer), pos);
return -1;
}
if (pos < length)
{
stream_set_pos(transport->recv_buffer, pos);
return 0; /* Packet is not yet completely received. */
}
/*
* A complete packet has been received. In case there are trailing data
* for the next packet, we copy it to the new receive buffer.
*/
received = transport->recv_buffer;
transport->recv_buffer = stream_new(BUFFER_SIZE);
if (pos > length)
{
stream_set_pos(received, length);
stream_check_size(transport->recv_buffer, pos - length);
stream_copy(transport->recv_buffer, received, pos - length);
}
stream_set_pos(received, length);
stream_seal(received);
stream_set_pos(received, 0);
if (transport->recv_callback(transport, received, transport->recv_extra) == false)
status = -1;
stream_free(received);
if (status < 0)
return status;
/* transport might now have been freed by rdp_client_redirect and a new rdp->transport created */
transport = *ptransport;
if (transport->process_single_pdu)
{
/* one at a time but set event if data buffered
* so the main loop will call freerdp_check_fds asap */
if (stream_get_pos(transport->recv_buffer) > 0)
wait_obj_set(transport->recv_event);
break;
}
}
return 0;
}
static void audin_server_send_version(audin_server* audin, STREAM* s)
{
stream_write_BYTE(s, MSG_SNDIN_VERSION);
stream_write_UINT32(s, 1); /* Version (4 bytes) */
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
static void* audin_server_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
BYTE MessageId;
BOOL ready = FALSE;
UINT32 bytes_returned = 0;
audin_server* audin = (audin_server*) arg;
freerdp_thread* thread = audin->audin_channel_thread;
if (WTSVirtualChannelQuery(audin->audin_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == TRUE)
{
fd = *((void**)buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = wait_obj_new_with_fd(fd);
}
/* Wait for the client to confirm that the Audio Input dynamic channel is ready */
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
if (WTSVirtualChannelQuery(audin->audin_channel, WTSVirtualChannelReady, &buffer, &bytes_returned) == FALSE)
break;
ready = *((BOOL*)buffer);
WTSFreeMemory(buffer);
if (ready)
break;
}
s = stream_new(4096);
if (ready)
{
audin_server_send_version(audin, s);
}
while (ready)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(audin->audin_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
{
if (bytes_returned == 0)
break;
stream_check_size(s, (int) bytes_returned);
if (WTSVirtualChannelRead(audin->audin_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
break;
}
if (bytes_returned < 1)
continue;
stream_read_BYTE(s, MessageId);
bytes_returned--;
switch (MessageId)
{
case MSG_SNDIN_VERSION:
if (audin_server_recv_version(audin, s, bytes_returned))
audin_server_send_formats(audin, s);
break;
case MSG_SNDIN_FORMATS:
if (audin_server_recv_formats(audin, s, bytes_returned))
audin_server_send_open(audin, s);
break;
case MSG_SNDIN_OPEN_REPLY:
audin_server_recv_open_reply(audin, s, bytes_returned);
break;
case MSG_SNDIN_DATA_INCOMING:
break;
case MSG_SNDIN_DATA:
audin_server_recv_data(audin, s, bytes_returned);
break;
case MSG_SNDIN_FORMATCHANGE:
break;
default:
printf("audin_server_thread_func: unknown MessageId %d\n", MessageId);
break;
}
}
stream_free(s);
WTSVirtualChannelClose(audin->audin_channel);
audin->audin_channel = NULL;
freerdp_thread_quit(thread);
return NULL;
}