static void rfx_compose_message_context(RFX_CONTEXT* context, STREAM* s)
{
UINT16 properties;
stream_write_UINT16(s, WBT_CONTEXT); /* CodecChannelT.blockType */
stream_write_UINT32(s, 13); /* CodecChannelT.blockLen */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
stream_write_BYTE(s, 0); /* ctxId */
stream_write_UINT16(s, CT_TILE_64x64); /* tileSize */
/* properties */
properties = context->flags; /* flags */
properties |= (COL_CONV_ICT << 3); /* cct */
properties |= (CLW_XFORM_DWT_53_A << 5); /* xft */
properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 9); /* et */
properties |= (SCALAR_QUANTIZATION << 13); /* qt */
stream_write_UINT16(s, properties);
/* properties in tilesets: note that this has different format from the one in TS_RFX_CONTEXT */
properties = 1; /* lt */
properties |= (context->flags << 1); /* flags */
properties |= (COL_CONV_ICT << 4); /* cct */
properties |= (CLW_XFORM_DWT_53_A << 6); /* xft */
properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 10); /* et */
properties |= (SCALAR_QUANTIZATION << 14); /* qt */
context->properties = properties;
}
void rdp_write_client_font_list_pdu(STREAM* s, UINT16 flags)
{
stream_write_UINT16(s, 0); /* numberFonts (2 bytes) */
stream_write_UINT16(s, 0); /* totalNumFonts (2 bytes) */
stream_write_UINT16(s, flags); /* listFlags (2 bytes) */
stream_write_UINT16(s, 50); /* entrySize (2 bytes) */
}
static void rfx_compose_message_sync(RFX_CONTEXT* context, STREAM* s)
{
stream_write_UINT16(s, WBT_SYNC); /* BlockT.blockType */
stream_write_UINT32(s, 12); /* BlockT.blockLen */
stream_write_UINT32(s, WF_MAGIC); /* magic */
stream_write_UINT16(s, WF_VERSION_1_0); /* version */
}
static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
{
STREAM* data_out;
WCHAR* computerNameW = NULL;
size_t computerNameLenW;
if (!rdpdr->computerName[0])
gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);
computerNameLenW = ConvertToUnicode(CP_UTF8, 0, rdpdr->computerName, -1, &computerNameW, 0) * 2;
data_out = stream_new(16 + computerNameLenW + 2);
stream_write_UINT16(data_out, RDPDR_CTYP_CORE);
stream_write_UINT16(data_out, PAKID_CORE_CLIENT_NAME);
stream_write_UINT32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
stream_write_UINT32(data_out, 0); /* codePage, must be set to zero */
stream_write_UINT32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */
stream_write(data_out, computerNameW, computerNameLenW);
stream_write_UINT16(data_out, 0); /* null terminator */
free(computerNameW);
svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
}
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);
}
static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
{
STREAM* data_out;
int error;
DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);
stream_seek(s, 1); /* pad */
stream_read_UINT16(s, drdynvc->version);
if (drdynvc->version == 2)
{
stream_read_UINT16(s, drdynvc->PriorityCharge0);
stream_read_UINT16(s, drdynvc->PriorityCharge1);
stream_read_UINT16(s, drdynvc->PriorityCharge2);
stream_read_UINT16(s, drdynvc->PriorityCharge3);
}
data_out = stream_new(4);
stream_write_UINT16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
stream_write_UINT16(data_out, drdynvc->version);
error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);
if (error != CHANNEL_RC_OK)
{
DEBUG_WARN("VirtualChannelWrite failed %d", error);
return 1;
}
drdynvc->channel_error = error;
return 0;
}
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);
}
void rail_write_rectangle_16(wStream* s, RECTANGLE_16* rectangle_16)
{
stream_write_UINT16(s, rectangle_16->left); /* left (2 bytes) */
stream_write_UINT16(s, rectangle_16->top); /* top (2 bytes) */
stream_write_UINT16(s, rectangle_16->right); /* right (2 bytes) */
stream_write_UINT16(s, rectangle_16->bottom); /* bottom (2 bytes) */
}
void license_write_binary_blob(STREAM* s, LICENSE_BLOB* blob)
{
stream_write_UINT16(s, blob->type); /* wBlobType (2 bytes) */
stream_write_UINT16(s, blob->length); /* wBlobLen (2 bytes) */
if (blob->length > 0)
stream_write(s, blob->data, blob->length); /* blobData */
}
void rail_write_client_window_move_order(STREAM* s, RAIL_WINDOW_MOVE_ORDER* window_move)
{
stream_write_UINT32(s, window_move->windowId); /* windowId (4 bytes) */
stream_write_UINT16(s, window_move->left); /* left (2 bytes) */
stream_write_UINT16(s, window_move->top); /* top (2 bytes) */
stream_write_UINT16(s, window_move->right); /* right (2 bytes) */
stream_write_UINT16(s, window_move->bottom); /* bottom (2 bytes) */
}
static void rfx_compose_message_codec_versions(RFX_CONTEXT* context, STREAM* s)
{
stream_write_UINT16(s, WBT_CODEC_VERSIONS); /* BlockT.blockType */
stream_write_UINT32(s, 10); /* BlockT.blockLen */
stream_write_BYTE(s, 1); /* numCodecs */
stream_write_BYTE(s, 1); /* codecs.codecId */
stream_write_UINT16(s, WF_VERSION_1_0); /* codecs.version */
}
static void rfx_compose_message_channels(RFX_CONTEXT* context, STREAM* s)
{
stream_write_UINT16(s, WBT_CHANNELS); /* BlockT.blockType */
stream_write_UINT32(s, 12); /* BlockT.blockLen */
stream_write_BYTE(s, 1); /* numChannels */
stream_write_BYTE(s, 0); /* Channel.channelId */
stream_write_UINT16(s, context->width); /* Channel.width */
stream_write_UINT16(s, context->height); /* Channel.height */
}
void rdp_write_share_control_header(STREAM* s, UINT16 length, UINT16 type, UINT16 channel_id)
{
length -= RDP_PACKET_HEADER_MAX_LENGTH;
/* Share Control Header */
stream_write_UINT16(s, length); /* totalLength */
stream_write_UINT16(s, type | 0x10); /* pduType */
stream_write_UINT16(s, channel_id); /* pduSource */
}
void update_write_surfcmd_frame_marker(STREAM* s, UINT16 frameAction, UINT32 frameId)
{
stream_check_size(s, SURFCMD_FRAME_MARKER_LENGTH);
stream_write_UINT16(s, CMDTYPE_FRAME_MARKER);
stream_write_UINT16(s, frameAction);
stream_write_UINT32(s, frameId);
}
void rail_write_client_exec_order(STREAM* s, RAIL_EXEC_ORDER* exec)
{
stream_write_UINT16(s, exec->flags); /* flags (2 bytes) */
stream_write_UINT16(s, exec->exeOrFile.length); /* exeOrFileLength (2 bytes) */
stream_write_UINT16(s, exec->workingDir.length); /* workingDirLength (2 bytes) */
stream_write_UINT16(s, exec->arguments.length); /* argumentsLength (2 bytes) */
rail_write_unicode_string_value(s, &exec->exeOrFile); /* exeOrFile */
rail_write_unicode_string_value(s, &exec->workingDir); /* workingDir */
rail_write_unicode_string_value(s, &exec->arguments); /* arguments */
}
static BOOL rdpsnd_server_set_volume(rdpsnd_server_context* context, int left, int right)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
STREAM* s = rdpsnd->rdpsnd_pdu;
RDPSND_PDU_INIT(s, SNDC_SETVOLUME);
stream_write_UINT16(s, left);
stream_write_UINT16(s, right);
RDPSND_PDU_FINISH(s);
}
wStream* cliprdr_packet_new(UINT16 msgType, UINT16 msgFlags, UINT32 dataLen)
{
wStream* s;
s = stream_new(dataLen + 8);
stream_write_UINT16(s, msgType);
stream_write_UINT16(s, msgFlags);
/* Write actual length after the entire packet has been constructed. */
stream_seek(s, 4);
return s;
}
BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp)
{
STREAM* s;
s = rdp_data_pdu_init(rdp);
stream_write_UINT16(s, 0); /* numberEntries (2 bytes) */
stream_write_UINT16(s, 0); /* totalNumEntries (2 bytes) */
stream_write_UINT16(s, FONTLIST_FIRST | FONTLIST_LAST); /* mapFlags (2 bytes) */
stream_write_UINT16(s, 4); /* entrySize (2 bytes) */
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->user_id);
}
void license_write_padded_binary_blob(STREAM* s, LICENSE_BLOB* blob)
{
UINT16 pad_len;
pad_len = 72 % blob->length;
stream_write_UINT16(s, blob->type); /* wBlobType (2 bytes) */
stream_write_UINT16(s, blob->length + pad_len); /* wBlobLen (2 bytes) */
if (blob->length > 0)
stream_write(s, blob->data, blob->length); /* blobData */
stream_write_zero(s, pad_len);
}
static void rfx_compose_message_frame_begin(RFX_CONTEXT* context, STREAM* s)
{
stream_check_size(s, 14);
stream_write_UINT16(s, WBT_FRAME_BEGIN); /* CodecChannelT.blockType */
stream_write_UINT32(s, 14); /* CodecChannelT.blockLen */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
stream_write_UINT32(s, context->frame_idx); /* frameIdx */
stream_write_UINT16(s, 1); /* numRegions */
context->frame_idx++;
}
static void update_write_suppress_output(STREAM* s, BYTE allow, RECTANGLE_16* area)
{
stream_write_BYTE(s, allow); /* allowDisplayUpdates (1 byte) */
stream_seek(s, 3); /* pad3Octets (3 bytes) */
if (allow > 0)
{
stream_write_UINT16(s, area->left); /* left (2 bytes) */
stream_write_UINT16(s, area->top); /* top (2 bytes) */
stream_write_UINT16(s, area->right); /* right (2 bytes) */
stream_write_UINT16(s, area->bottom); /* bottom (2 bytes) */
}
}
static void rfx_compose_message_region(RFX_CONTEXT* context, STREAM* s,
const RFX_RECT* rects, int num_rects)
{
int size;
int i;
size = 15 + num_rects * 8;
stream_check_size(s, size);
stream_write_UINT16(s, WBT_REGION); /* CodecChannelT.blockType */
stream_write_UINT32(s, size); /* set CodecChannelT.blockLen later */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
stream_write_BYTE(s, 1); /* regionFlags */
stream_write_UINT16(s, num_rects); /* numRects */
for (i = 0; i < num_rects; i++)
{
stream_write_UINT16(s, rects[i].x);
stream_write_UINT16(s, rects[i].y);
stream_write_UINT16(s, rects[i].width);
stream_write_UINT16(s, rects[i].height);
}
stream_write_UINT16(s, CBT_REGION); /* regionType */
stream_write_UINT16(s, 1); /* numTilesets */
}
BOOL rdp_send_server_control_granted_pdu(rdpRdp* rdp)
{
STREAM* s;
s = rdp_data_pdu_init(rdp);
stream_write_UINT16(s, CTRLACTION_GRANTED_CONTROL); /* action (2 bytes) */
stream_write_UINT16(s, rdp->mcs->user_id); /* grantId (2 bytes) */
stream_write_UINT32(s, 0x03EA); /* controlId (4 bytes) */
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->user_id);
return TRUE;
}
void rdp_write_share_data_header(STREAM* s, UINT16 length, BYTE type, UINT32 share_id)
{
length -= RDP_PACKET_HEADER_MAX_LENGTH;
length -= RDP_SHARE_CONTROL_HEADER_LENGTH;
length -= RDP_SHARE_DATA_HEADER_LENGTH;
/* Share Data Header */
stream_write_UINT32(s, share_id); /* shareId (4 bytes) */
stream_write_BYTE(s, 0); /* pad1 (1 byte) */
stream_write_BYTE(s, STREAM_LOW); /* streamId (1 byte) */
stream_write_UINT16(s, length); /* uncompressedLength (2 bytes) */
stream_write_BYTE(s, type); /* pduType2, Data PDU Type (1 byte) */
stream_write_BYTE(s, 0); /* compressedType (1 byte) */
stream_write_UINT16(s, 0); /* compressedLength (2 bytes) */
}
static void update_write_refresh_rect(STREAM* s, BYTE count, RECTANGLE_16* areas)
{
int i;
stream_write_BYTE(s, count); /* numberOfAreas (1 byte) */
stream_seek(s, 3); /* pad3Octets (3 bytes) */
for (i = 0; i < count; i++)
{
stream_write_UINT16(s, areas[i].left); /* left (2 bytes) */
stream_write_UINT16(s, areas[i].top); /* top (2 bytes) */
stream_write_UINT16(s, areas[i].right); /* right (2 bytes) */
stream_write_UINT16(s, areas[i].bottom); /* bottom (2 bytes) */
}
}
static void rdpdr_send_client_announce_reply(rdpdrPlugin* rdpdr)
{
STREAM* data_out;
data_out = stream_new(12);
stream_write_UINT16(data_out, RDPDR_CTYP_CORE);
stream_write_UINT16(data_out, PAKID_CORE_CLIENTID_CONFIRM);
stream_write_UINT16(data_out, rdpdr->versionMajor);
stream_write_UINT16(data_out, rdpdr->versionMinor);
stream_write_UINT32(data_out, (UINT32) rdpdr->clientID);
svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
}
void rts_pdu_header_write(STREAM* s, RTS_PDU_HEADER* header)
{
stream_write_BYTE(s, header->rpc_vers); /* rpc_vers (1 byte) */
stream_write_BYTE(s, header->rpc_vers_minor); /* rpc_vers_minor (1 byte) */
stream_write_BYTE(s, header->ptype); /* PTYPE (1 byte) */
stream_write_BYTE(s, header->pfc_flags); /* pfc_flags (1 byte) */
stream_write_BYTE(s, header->packed_drep[0]); /* packet_drep[0] (1 byte) */
stream_write_BYTE(s, header->packed_drep[1]); /* packet_drep[1] (1 byte) */
stream_write_BYTE(s, header->packed_drep[2]); /* packet_drep[2] (1 byte) */
stream_write_BYTE(s, header->packed_drep[3]); /* packet_drep[3] (1 byte) */
stream_write_UINT16(s, header->frag_length); /* frag_length (2 bytes) */
stream_write_UINT16(s, header->auth_length); /* auth_length (2 bytes) */
stream_write_UINT32(s, header->call_id); /* call_id (4 bytes) */
stream_write_UINT16(s, header->flags); /* flags (2 bytes) */
stream_write_UINT16(s, header->numberOfCommands); /* numberOfCommands (2 bytes) */
}
void tpdu_write_header(STREAM* s, UINT16 length, BYTE code)
{
stream_write_BYTE(s, length); /* LI */
stream_write_BYTE(s, code); /* code */
if (code == X224_TPDU_DATA)
{
stream_write_BYTE(s, 0x80); /* EOT */
}
else
{
stream_write_UINT16(s, 0); /* DST-REF */
stream_write_UINT16(s, 0); /* SRC-REF */
stream_write_BYTE(s, 0); /* Class 0 */
}
}
void license_write_preamble(STREAM* s, BYTE bMsgType, BYTE flags, UINT16 wMsgSize)
{
/* preamble (4 bytes) */
stream_write_BYTE(s, bMsgType); /* bMsgType (1 byte) */
stream_write_BYTE(s, flags); /* flags (1 byte) */
stream_write_UINT16(s, wMsgSize); /* wMsgSize (2 bytes) */
}
void gcc_write_server_network_data(STREAM* s, rdpSettings* settings)
{
int i;
gcc_write_user_data_header(s, SC_NET, 8 + settings->ChannelCount * 2 + (settings->ChannelCount % 2 == 1 ? 2 : 0));
stream_write_UINT16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
stream_write_UINT16(s, settings->ChannelCount); /* channelCount */
for (i = 0; i < settings->ChannelCount; i++)
{
stream_write_UINT16(s, settings->ChannelDefArray[i].ChannelId);
}
if (settings->ChannelCount % 2 == 1)
stream_write_UINT16(s, 0);
}