return RDPGFX_HEADER_SIZE + dataLen;
}
-static INLINE UINT rdpgfx_server_packet_init_header(wStream* s, UINT16 cmdId, UINT32 pduLength)
+static INLINE UINT rdpgfx_server_packet_init_header(wStream* s,
+ UINT16 cmdId, UINT32 pduLength)
{
RDPGFX_HEADER header;
-
header.flags = 0;
header.cmdId = cmdId;
header.pduLength = pduLength;
-
- /* Write header. Note that actual length might be changed
+ /* Write header. Note that actual length might be changed
* after the entire packet has been constructed. */
return rdpgfx_write_header(s, &header);
}
static INLINE void rdpgfx_server_packet_complete_header(wStream* s, size_t start)
{
size_t current = Stream_GetPosition(s);
-
/* Fill actual length */
Stream_SetPosition(s, start + RDPGFX_HEADER_SIZE - sizeof(UINT32));
Stream_Write_UINT32(s, current - start); /* pduLength (4 bytes) */
/**
* Function description
- * Send the stream for rdpgfx server packet.
+ * Send the stream for rdpgfx server packet.
* The packet would be compressed according to [MS-RDPEGFX].
*
* @return 0 on success, otherwise a Win32 error code
BYTE* pSrcData = Stream_Buffer(s);
UINT32 SrcSize = Stream_GetPosition(s);
wStream* fs;
-
/* Allocate new stream with enough capacity. Additional overhead is
* descriptor (1 bytes) + segmentCount (2 bytes) + uncompressedSize (4 bytes)
* + segmentCount * size (4 bytes) */
- fs = Stream_New(NULL, SrcSize + 7
- + (SrcSize/ZGFX_SEGMENTED_MAXSIZE + 1) * 4);
+ fs = Stream_New(NULL, SrcSize + 7
+ + (SrcSize/ZGFX_SEGMENTED_MAXSIZE + 1) * 4);
- if(!fs)
+ if (!fs)
{
- WLog_ERR(TAG, "Stream_New failed!");
+ WLog_ERR(TAG, "Stream_New failed!");
error = CHANNEL_RC_NO_MEMORY;
- goto out;
+ goto out;
}
- if (zgfx_compress_to_stream(context->priv->zgfx, fs, pSrcData, SrcSize, &flags) < 0)
+ if (zgfx_compress_to_stream(context->priv->zgfx, fs, pSrcData,
+ SrcSize, &flags) < 0)
{
WLog_ERR(TAG, "zgfx_compress_to_stream failed!");
error = ERROR_INTERNAL_ERROR;
goto out;
}
- if (!WTSVirtualChannelWrite(context->priv->rdpgfx_channel,
- (PCHAR) Stream_Buffer(fs),
- Stream_GetPosition(fs), &written))
+ if (!WTSVirtualChannelWrite(context->priv->rdpgfx_channel,
+ (PCHAR) Stream_Buffer(fs),
+ Stream_GetPosition(fs), &written))
{
WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
error = ERROR_INTERNAL_ERROR;
if (written < Stream_GetPosition(fs))
{
- WLog_WARN(TAG, "Unexpected bytes written: %lu/%lu",
- written, Stream_GetPosition(fs));
+ WLog_WARN(TAG, "Unexpected bytes written: %lu/%lu",
+ written, Stream_GetPosition(fs));
}
error = CHANNEL_RC_OK;
-
out:
Stream_Free(fs, TRUE);
Stream_Free(s, TRUE);
-
return error;
}
* Function description
* Create new stream for single rdpgfx packet. The new stream length
* would be required data length + header. The header will be written
- * to the stream before return, but the pduLength field might be
+ * to the stream before return, but the pduLength field might be
* changed in rdpgfx_server_single_packet_send.
*
- * @param cmdId
+ * @param cmdId
* @param dataLen estimated data length without header
*
* @return new stream
{
UINT error;
wStream* s;
- UINT32 pduLength = rdpgfx_pdu_length(dataLen);
-
+ UINT32 pduLength = rdpgfx_pdu_length(dataLen);
s = Stream_New(NULL, pduLength);
- if(!s)
+ if (!s)
{
- WLog_ERR(TAG, "Stream_New failed!");
- goto error;
+ WLog_ERR(TAG, "Stream_New failed!");
+ goto error;
}
if ((error = rdpgfx_server_packet_init_header(s, cmdId, pduLength)))
{
WLog_ERR(TAG, "Failed to init header with error %lu!", error);
- goto error;
+ goto error;
}
return s;
-
error:
Stream_Free(s, TRUE);
-
return NULL;
}
/**
* Function description
- * Send the stream for single rdpgfx packet.
+ * Send the stream for single rdpgfx packet.
* The header will be filled with actual length.
* The packet would be compressed according to [MS-RDPEGFX].
*
* @return 0 on success, otherwise a Win32 error code
*/
-static INLINE UINT rdpgfx_server_single_packet_send(RdpgfxServerContext* context, wStream* s)
+static INLINE UINT rdpgfx_server_single_packet_send(
+ RdpgfxServerContext* context, wStream* s)
{
/* Fill actual length */
rdpgfx_server_packet_complete_header(s, 0);
-
return rdpgfx_server_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_caps_confirm_pdu(RdpgfxServerContext* context, RDPGFX_CAPS_CONFIRM_PDU* capsConfirm)
+static UINT rdpgfx_send_caps_confirm_pdu(RdpgfxServerContext* context,
+ RDPGFX_CAPS_CONFIRM_PDU* capsConfirm)
{
RDPGFX_CAPSET* capsSet = capsConfirm->capsSet;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_CAPSCONFIRM,
- sizeof(RDPGFX_CAPSET) + sizeof(capsSet->flags));
+ RDPGFX_CMDID_CAPSCONFIRM,
+ sizeof(RDPGFX_CAPSET) + sizeof(capsSet->flags));
if (!s)
{
Stream_Write_UINT32(s, capsSet->version); /* version (4 bytes) */
Stream_Write_UINT32(s, sizeof(capsSet->flags)); /* capsDataLength (4 bytes) */
Stream_Write_UINT32(s, capsSet->flags); /* capsData (4 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_reset_graphics_pdu(RdpgfxServerContext* context, RDPGFX_RESET_GRAPHICS_PDU* pdu)
+static UINT rdpgfx_send_reset_graphics_pdu(RdpgfxServerContext* context,
+ RDPGFX_RESET_GRAPHICS_PDU* pdu)
{
UINT32 index;
MONITOR_DEF* monitor;
wStream* s;
-
+
/* Check monitorCount. This ensures total size within 340 bytes) */
if (pdu->monitorCount >= 16)
{
WLog_ERR(TAG, "Monitor count MUST be less than or equal to 16: %lu",
- pdu->monitorCount);
+ pdu->monitorCount);
return ERROR_INVALID_DATA;
}
s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_RESETGRAPHICS,
- RDPGFX_RESET_GRAPHICS_PDU_SIZE - RDPGFX_HEADER_SIZE);
+ RDPGFX_CMDID_RESETGRAPHICS,
+ RDPGFX_RESET_GRAPHICS_PDU_SIZE - RDPGFX_HEADER_SIZE);
if (!s)
{
/* pad (total size must be 340 bytes) */
Stream_SetPosition(s, RDPGFX_RESET_GRAPHICS_PDU_SIZE);
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_evict_cache_entry_pdu(RdpgfxServerContext* context, RDPGFX_EVICT_CACHE_ENTRY_PDU* pdu)
+static UINT rdpgfx_send_evict_cache_entry_pdu(RdpgfxServerContext* context,
+ RDPGFX_EVICT_CACHE_ENTRY_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_EVICTCACHEENTRY,
- sizeof(RDPGFX_EVICT_CACHE_ENTRY_PDU));
+ RDPGFX_CMDID_EVICTCACHEENTRY,
+ sizeof(RDPGFX_EVICT_CACHE_ENTRY_PDU));
if (!s)
{
}
Stream_Write_UINT16(s, pdu->cacheSlot); /* cacheSlot (2 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_cache_import_reply_pdu(RdpgfxServerContext* context, RDPGFX_CACHE_IMPORT_REPLY_PDU* pdu)
+static UINT rdpgfx_send_cache_import_reply_pdu(RdpgfxServerContext* context,
+ RDPGFX_CACHE_IMPORT_REPLY_PDU* pdu)
{
UINT16 index;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_CACHEIMPORTREPLY,
- sizeof(RDPGFX_CACHE_IMPORT_REPLY_PDU) + sizeof(UINT16) * pdu->importedEntriesCount);
+ RDPGFX_CMDID_CACHEIMPORTREPLY,
+ sizeof(RDPGFX_CACHE_IMPORT_REPLY_PDU) +
+ sizeof(UINT16) * pdu->importedEntriesCount);
if (!s)
{
return CHANNEL_RC_NO_MEMORY;
}
- Stream_Write_UINT16(s, pdu->importedEntriesCount); /* importedEntriesCount (2 bytes) */
+ /* importedEntriesCount (2 bytes) */
+ Stream_Write_UINT16(s, pdu->importedEntriesCount);
+
for (index = 0; index < pdu->importedEntriesCount; index++)
{
Stream_Write_UINT16(s, pdu->cacheSlots[index]); /* cacheSlot (2 bytes) */
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_create_surface_pdu(RdpgfxServerContext* context, RDPGFX_CREATE_SURFACE_PDU* pdu)
+static UINT rdpgfx_send_create_surface_pdu(RdpgfxServerContext* context,
+ RDPGFX_CREATE_SURFACE_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_CREATESURFACE,
- sizeof(RDPGFX_CREATE_SURFACE_PDU));
+ RDPGFX_CMDID_CREATESURFACE,
+ sizeof(RDPGFX_CREATE_SURFACE_PDU));
if (!s)
{
Stream_Write_UINT16(s, pdu->width); /* width (2 bytes) */
Stream_Write_UINT16(s, pdu->height); /* height (2 bytes) */
Stream_Write_UINT8(s, pdu->pixelFormat); /* RDPGFX_PIXELFORMAT (1 byte) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-UINT rdpgfx_send_delete_surface_pdu(RdpgfxServerContext* context, RDPGFX_DELETE_SURFACE_PDU* pdu)
+UINT rdpgfx_send_delete_surface_pdu(RdpgfxServerContext* context,
+ RDPGFX_DELETE_SURFACE_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_DELETESURFACE,
- sizeof(RDPGFX_DELETE_SURFACE_PDU));
+ RDPGFX_CMDID_DELETESURFACE,
+ sizeof(RDPGFX_DELETE_SURFACE_PDU));
if (!s)
{
}
Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
-static INLINE void rdpgfx_write_start_frame_pdu(wStream* s, RDPGFX_START_FRAME_PDU* pdu)
+static INLINE void rdpgfx_write_start_frame_pdu(wStream* s,
+ RDPGFX_START_FRAME_PDU* pdu)
{
Stream_Write_UINT32(s, pdu->timestamp); /* timestamp (4 bytes) */
Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */
}
-static INLINE void rdpgfx_write_end_frame_pdu(wStream* s, RDPGFX_END_FRAME_PDU* pdu)
+static INLINE void rdpgfx_write_end_frame_pdu(wStream* s,
+ RDPGFX_END_FRAME_PDU* pdu)
{
Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_start_frame_pdu(RdpgfxServerContext* context, RDPGFX_START_FRAME_PDU* pdu)
+static UINT rdpgfx_send_start_frame_pdu(RdpgfxServerContext* context,
+ RDPGFX_START_FRAME_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_STARTFRAME,
- sizeof(RDPGFX_START_FRAME_PDU));
+ RDPGFX_CMDID_STARTFRAME,
+ sizeof(RDPGFX_START_FRAME_PDU));
if (!s)
{
}
rdpgfx_write_start_frame_pdu(s, pdu);
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_end_frame_pdu(RdpgfxServerContext* context, RDPGFX_END_FRAME_PDU* pdu)
+static UINT rdpgfx_send_end_frame_pdu(RdpgfxServerContext* context,
+ RDPGFX_END_FRAME_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_ENDFRAME,
- sizeof(RDPGFX_END_FRAME_PDU));
+ RDPGFX_CMDID_ENDFRAME,
+ sizeof(RDPGFX_END_FRAME_PDU));
if (!s)
{
}
rdpgfx_write_end_frame_pdu(s, pdu);
-
return rdpgfx_server_single_packet_send(context, s);
}
/**
* Function description
- * Estimate RFX_AVC420_BITMAP_STREAM structure size in stream
+ * Estimate RFX_AVC420_BITMAP_STREAM structure size in stream
*
* @return estimated size
*/
-static INLINE UINT32 rdpgfx_estimate_h264_avc420(RDPGFX_AVC420_BITMAP_STREAM *havc420)
+static INLINE UINT32 rdpgfx_estimate_h264_avc420(
+ RDPGFX_AVC420_BITMAP_STREAM* havc420)
{
return sizeof(UINT32) /* numRegionRects */
- + (sizeof(RECTANGLE_16) + 2) /* regionRects + quantQualityVals */
- * havc420->meta.numRegionRects
- + havc420->length;
+ + (sizeof(RECTANGLE_16) + 2) /* regionRects + quantQualityVals */
+ * havc420->meta.numRegionRects
+ + havc420->length;
}
/**
*/
static INLINE UINT32 rdpgfx_estimate_surface_command(RDPGFX_SURFACE_COMMAND* cmd)
{
- RDPGFX_AVC420_BITMAP_STREAM *havc420 = NULL;
- RDPGFX_AVC444_BITMAP_STREAM *havc444 = NULL;
+ RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;
+ RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;
UINT32 h264Size = 0;
/* Create new stream according to codec. */
if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||
- cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
+ cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
{
return sizeof(RDPGFX_WIRE_TO_SURFACE_PDU_2) + cmd->length;
}
else if (cmd->codecId == RDPGFX_CODECID_AVC420)
{
- havc420 = (RDPGFX_AVC420_BITMAP_STREAM *)cmd->extra;
+ havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
h264Size = rdpgfx_estimate_h264_avc420(havc420);
-
return sizeof(RDPGFX_WIRE_TO_SURFACE_PDU_1) + h264Size;
}
else if (cmd->codecId == RDPGFX_CODECID_AVC444)
{
- havc444 = (RDPGFX_AVC444_BITMAP_STREAM *)cmd->extra;
+ havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
h264Size = sizeof(UINT32); /* cbAvc420EncodedBitstream1 */
-
/* avc420EncodedBitstream1 */
havc420 = &(havc444->bitstream[0]);
h264Size += rdpgfx_estimate_h264_avc420(havc420);
/**
* Function description
- * Resolve RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
+ * Resolve RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
* according to codecId
*
* @return 0 on success, otherwise a Win32 error code
static INLINE UINT16 rdpgfx_surface_command_cmdid(RDPGFX_SURFACE_COMMAND* cmd)
{
if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||
- cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
+ cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
{
return RDPGFX_CMDID_WIRETOSURFACE_2;
}
RECTANGLE_16* regionRect;
RDPGFX_H264_QUANT_QUALITY* quantQualityVal;
UINT error = CHANNEL_RC_OK;
-
Stream_Write_UINT32(s, meta->numRegionRects); /* numRegionRects (4 bytes) */
for (index = 0; index < meta->numRegionRects; index++)
{
regionRect = &(meta->regionRects[index]);
+
if ((error = rdpgfx_write_rect16(s, regionRect)))
{
WLog_ERR(TAG, "rdpgfx_write_rect16 failed with error %lu!", error);
for (index = 0; index < meta->numRegionRects; index++)
{
quantQualityVal = &(meta->quantQualityVals[index]);
-
Stream_Write_UINT8(s, quantQualityVal->qp
- | (quantQualityVal->r << 6)
- | (quantQualityVal->p << 7)); /* qpVal (1 byte) */
- Stream_Write_UINT8(s, quantQualityVal->qualityVal); /* qualityVal (1 byte) */
+ | (quantQualityVal->r << 6)
+ | (quantQualityVal->p << 7)); /* qpVal (1 byte) */
+ /* qualityVal (1 byte) */
+ Stream_Write_UINT8(s, quantQualityVal->qualityVal);
}
return error;
*
* @return 0 on success, otherwise a Win32 error code
*/
-static INLINE UINT rdpgfx_write_h264_avc420(wStream* s, RDPGFX_AVC420_BITMAP_STREAM* havc420)
+static INLINE UINT rdpgfx_write_h264_avc420(wStream* s,
+ RDPGFX_AVC420_BITMAP_STREAM* havc420)
{
UINT error = CHANNEL_RC_OK;
+
if ((error = rdpgfx_write_h264_metablock(s, &(havc420->meta))))
{
- WLog_ERR(TAG, "rdpgfx_write_h264_metablock failed with error %lu!", error);
+ WLog_ERR(TAG, "rdpgfx_write_h264_metablock failed with error %lu!",
+ error);
return error;
}
static UINT rdpgfx_write_surface_command(wStream* s, RDPGFX_SURFACE_COMMAND* cmd)
{
UINT error = CHANNEL_RC_OK;
- RDPGFX_AVC420_BITMAP_STREAM *havc420 = NULL;
- RDPGFX_AVC444_BITMAP_STREAM *havc444 = NULL;
+ RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;
+ RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;
UINT32 bitmapDataStart = 0;
UINT32 bitmapDataLength = 0;
if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||
- cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
+ cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
{
/* Write RDPGFX_CMDID_WIRETOSURFACE_2 format for CAPROGRESSIVE */
-
Stream_Write_UINT16(s, cmd->surfaceId); /* surfaceId (2 bytes) */
Stream_Write_UINT16(s, cmd->codecId); /* codecId (2 bytes) */
Stream_Write_UINT32(s, cmd->contextId); /* codecContextId (4 bytes) */
Stream_Write_UINT8(s, cmd->format); /* pixelFormat (1 byte) */
-
Stream_Write_UINT32(s, cmd->length); /* bitmapDataLength (4 bytes) */
Stream_Write(s, cmd->data, cmd->length);
}
else
{
/* Write RDPGFX_CMDID_WIRETOSURFACE_1 format for others */
-
Stream_Write_UINT16(s, cmd->surfaceId); /* surfaceId (2 bytes) */
Stream_Write_UINT16(s, cmd->codecId); /* codecId (2 bytes) */
Stream_Write_UINT8(s, cmd->format); /* pixelFormat (1 byte) */
-
Stream_Write_UINT16(s, cmd->left); /* left (2 bytes) */
Stream_Write_UINT16(s, cmd->top); /* top (2 bytes) */
Stream_Write_UINT16(s, cmd->right); /* right (2 bytes) */
Stream_Write_UINT16(s, cmd->bottom); /* bottom (2 bytes) */
-
Stream_Write_UINT32(s, cmd->length); /* bitmapDataLength (4 bytes) */
bitmapDataStart = Stream_GetPosition(s);
if (cmd->codecId == RDPGFX_CODECID_AVC420)
{
- havc420 = (RDPGFX_AVC420_BITMAP_STREAM *)cmd->extra;
+ havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
error = rdpgfx_write_h264_avc420(s, havc420);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
}
else if (cmd->codecId == RDPGFX_CODECID_AVC444)
{
- havc444 = (RDPGFX_AVC444_BITMAP_STREAM *)cmd->extra;
+ havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
havc420 = &(havc444->bitstream[0]);
-
/* avc420EncodedBitstreamInfo (4 bytes) */
Stream_Write_UINT32(s, havc420->length | (havc444->LC << 30UL));
-
/* avc420EncodedBitstream1 */
error = rdpgfx_write_h264_avc420(s, havc420);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
{
havc420 = &(havc444->bitstream[0]);
error = rdpgfx_write_h264_avc420(s, havc420);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
}
assert(Stream_GetPosition(s) <= Stream_Capacity(s));
-
/* Fill actual bitmap data length */
bitmapDataLength = Stream_GetPosition(s) - bitmapDataStart;
Stream_SetPosition(s, bitmapDataStart - sizeof(UINT32));
/**
* Function description
- * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
+ * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
* message according to codecId
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_surface_command(RdpgfxServerContext* context, RDPGFX_SURFACE_COMMAND* cmd)
+static UINT rdpgfx_send_surface_command(RdpgfxServerContext* context,
+ RDPGFX_SURFACE_COMMAND* cmd)
{
UINT error = CHANNEL_RC_OK;
wStream* s;
-
s = rdpgfx_server_single_packet_new(
- rdpgfx_surface_command_cmdid(cmd),
- rdpgfx_estimate_surface_command(cmd));
+ rdpgfx_surface_command_cmdid(cmd),
+ rdpgfx_estimate_surface_command(cmd));
if (!s)
{
}
error = rdpgfx_write_surface_command(s, cmd);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "rdpgfx_write_surface_command failed!");
}
return rdpgfx_server_single_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
/**
* Function description
- * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
+ * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2
* message according to codecId.
* Prepend/append start/end frame message in same packet if exists.
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpgfx_send_surface_frame_command(RdpgfxServerContext* context,
- RDPGFX_SURFACE_COMMAND* cmd, RDPGFX_START_FRAME_PDU* startFrame,
- RDPGFX_END_FRAME_PDU* endFrame)
+ RDPGFX_SURFACE_COMMAND* cmd, RDPGFX_START_FRAME_PDU* startFrame,
+ RDPGFX_END_FRAME_PDU* endFrame)
{
UINT error = CHANNEL_RC_OK;
s = Stream_New(NULL, size);
- if(!s)
+ if (!s)
{
- WLog_ERR(TAG, "Stream_New failed!");
+ WLog_ERR(TAG, "Stream_New failed!");
return CHANNEL_RC_NO_MEMORY;
}
if (startFrame)
{
position = Stream_GetPosition(s);
- error = rdpgfx_server_packet_init_header(s,
- RDPGFX_CMDID_STARTFRAME, 0);
+ error = rdpgfx_server_packet_init_header(s,
+ RDPGFX_CMDID_STARTFRAME, 0);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "Failed to init header with error %lu!", error);
/* Write RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2 */
position = Stream_GetPosition(s);
- error = rdpgfx_server_packet_init_header(s,
- rdpgfx_surface_command_cmdid(cmd),
- 0); // Actual length will be filled later
+ error = rdpgfx_server_packet_init_header(s,
+ rdpgfx_surface_command_cmdid(cmd),
+ 0); // Actual length will be filled later
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "Failed to init header with error %lu!", error);
}
error = rdpgfx_write_surface_command(s, cmd);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "rdpgfx_write_surface_command failed!");
goto error;
}
+
rdpgfx_server_packet_complete_header(s, position);
/* Write end frame if exists */
if (endFrame)
{
position = Stream_GetPosition(s);
- error = rdpgfx_server_packet_init_header(s,
- RDPGFX_CMDID_ENDFRAME, 0);
+ error = rdpgfx_server_packet_init_header(s,
+ RDPGFX_CMDID_ENDFRAME, 0);
+
if (error != CHANNEL_RC_OK)
{
WLog_ERR(TAG, "Failed to init header with error %lu!", error);
}
return rdpgfx_server_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_delete_encoding_context_pdu(RdpgfxServerContext* context, RDPGFX_DELETE_ENCODING_CONTEXT_PDU* pdu)
+static UINT rdpgfx_send_delete_encoding_context_pdu(RdpgfxServerContext* context,
+ RDPGFX_DELETE_ENCODING_CONTEXT_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_DELETEENCODINGCONTEXT,
- sizeof(RDPGFX_DELETE_ENCODING_CONTEXT_PDU));
+ RDPGFX_CMDID_DELETEENCODINGCONTEXT,
+ sizeof(RDPGFX_DELETE_ENCODING_CONTEXT_PDU));
if (!s)
{
Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
Stream_Write_UINT32(s, pdu->codecContextId); /* codecContextId (4 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-UINT rdpgfx_send_solid_fill_pdu(RdpgfxServerContext* context, RDPGFX_SOLID_FILL_PDU* pdu)
+UINT rdpgfx_send_solid_fill_pdu(RdpgfxServerContext* context,
+ RDPGFX_SOLID_FILL_PDU* pdu)
{
UINT error = CHANNEL_RC_OK;
UINT16 index;
RECTANGLE_16* fillRect;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_SOLIDFILL,
- sizeof(RDPGFX_SOLID_FILL_PDU) + sizeof(RECTANGLE_16) * pdu->fillRectCount);
+ RDPGFX_CMDID_SOLIDFILL,
+ sizeof(RDPGFX_SOLID_FILL_PDU) +
+ sizeof(RECTANGLE_16) * pdu->fillRectCount);
if (!s)
{
}
Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
- if ((error = rdpgfx_write_color32(s, &(pdu->fillPixel)))) /* fillPixel (4 bytes) */
+
+ /* fillPixel (4 bytes) */
+ if ((error = rdpgfx_write_color32(s, &(pdu->fillPixel))))
{
WLog_ERR(TAG, "rdpgfx_write_color32 failed with error %lu!", error);
goto error;
}
Stream_Write_UINT16(s, pdu->fillRectCount); /* fillRectCount (2 bytes) */
+
for (index = 0; index < pdu->fillRectCount; index++)
{
fillRect = &(pdu->fillRects[index]);
+
if ((error = rdpgfx_write_rect16(s, fillRect)))
{
WLog_ERR(TAG, "rdpgfx_write_rect16 failed with error %lu!", error);
}
return rdpgfx_server_single_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_surface_to_surface_pdu(RdpgfxServerContext* context, RDPGFX_SURFACE_TO_SURFACE_PDU* pdu)
+static UINT rdpgfx_send_surface_to_surface_pdu(RdpgfxServerContext* context,
+ RDPGFX_SURFACE_TO_SURFACE_PDU* pdu)
{
UINT error = CHANNEL_RC_OK;
UINT16 index;
RDPGFX_POINT16* destPt;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_SURFACETOSURFACE,
- sizeof(RDPGFX_SURFACE_TO_SURFACE_PDU) + sizeof(RDPGFX_POINT16) * pdu->destPtsCount);
+ RDPGFX_CMDID_SURFACETOSURFACE,
+ sizeof(RDPGFX_SURFACE_TO_SURFACE_PDU) +
+ sizeof(RDPGFX_POINT16) * pdu->destPtsCount);
if (!s)
{
Stream_Write_UINT16(s, pdu->surfaceIdSrc); /* surfaceIdSrc (2 bytes) */
Stream_Write_UINT16(s, pdu->surfaceIdDest); /* surfaceIdDest (2 bytes) */
- if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc)))) /* rectSrc (8 bytes ) */
+ /* rectSrc (8 bytes ) */
+ if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc))))
{
WLog_ERR(TAG, "rdpgfx_write_rect16 failed with error %lu!", error);
goto error;
}
Stream_Write_UINT16(s, pdu->destPtsCount); /* destPtsCount (2 bytes) */
+
for (index = 0; index < pdu->destPtsCount; index++)
{
destPt = &(pdu->destPts[index]);
+
if ((error = rdpgfx_write_point16(s, destPt)))
{
WLog_ERR(TAG, "rdpgfx_write_point16 failed with error %lu!", error);
}
return rdpgfx_server_single_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_surface_to_cache_pdu(RdpgfxServerContext* context, RDPGFX_SURFACE_TO_CACHE_PDU* pdu)
+static UINT rdpgfx_send_surface_to_cache_pdu(RdpgfxServerContext* context,
+ RDPGFX_SURFACE_TO_CACHE_PDU* pdu)
{
UINT error = CHANNEL_RC_OK;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_SURFACETOCACHE,
- sizeof(RDPGFX_SURFACE_TO_CACHE_PDU));
+ RDPGFX_CMDID_SURFACETOCACHE,
+ sizeof(RDPGFX_SURFACE_TO_CACHE_PDU));
if (!s)
{
Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
Stream_Write_UINT64(s, pdu->cacheKey); /* cacheKey (8 bytes) */
Stream_Write_UINT16(s, pdu->cacheSlot); /* cacheSlot (2 bytes) */
- if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc)))) /* rectSrc (8 bytes ) */
+
+ /* rectSrc (8 bytes ) */
+ if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc))))
{
WLog_ERR(TAG, "rdpgfx_write_rect16 failed with error %lu!", error);
goto error;
}
return rdpgfx_server_single_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_cache_to_surface_pdu(RdpgfxServerContext* context, RDPGFX_CACHE_TO_SURFACE_PDU* pdu)
+static UINT rdpgfx_send_cache_to_surface_pdu(RdpgfxServerContext* context,
+ RDPGFX_CACHE_TO_SURFACE_PDU* pdu)
{
UINT error = CHANNEL_RC_OK;
UINT16 index;
RDPGFX_POINT16* destPt;
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_CACHETOSURFACE,
- sizeof(RDPGFX_CACHE_TO_SURFACE_PDU) + sizeof(RDPGFX_POINT16) * pdu->destPtsCount);
+ RDPGFX_CMDID_CACHETOSURFACE,
+ sizeof(RDPGFX_CACHE_TO_SURFACE_PDU) +
+ sizeof(RDPGFX_POINT16) * pdu->destPtsCount);
if (!s)
{
for (index = 0; index < pdu->destPtsCount; index++)
{
destPt = &(pdu->destPts[index]);
+
if ((error = rdpgfx_write_point16(s, destPt)))
{
WLog_ERR(TAG, "rdpgfx_write_point16 failed with error %lu", error);
}
return rdpgfx_server_single_packet_send(context, s);
-
error:
Stream_Free(s, TRUE);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_map_surface_to_output_pdu(RdpgfxServerContext* context, RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* pdu)
+static UINT rdpgfx_send_map_surface_to_output_pdu(RdpgfxServerContext* context,
+ RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_MAPSURFACETOOUTPUT,
- sizeof(RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU));
+ RDPGFX_CMDID_MAPSURFACETOOUTPUT,
+ sizeof(RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU));
if (!s)
{
Stream_Write_UINT16(s, 0); /* reserved (2 bytes). Must be 0 */
Stream_Write_UINT32(s, pdu->outputOriginX); /* outputOriginX (4 bytes) */
Stream_Write_UINT32(s, pdu->outputOriginY); /* outputOriginY (4 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_send_map_surface_to_window_pdu(RdpgfxServerContext* context, RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* pdu)
+static UINT rdpgfx_send_map_surface_to_window_pdu(RdpgfxServerContext* context,
+ RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* pdu)
{
wStream* s = rdpgfx_server_single_packet_new(
- RDPGFX_CMDID_MAPSURFACETOWINDOW,
- sizeof(RDPGFX_MAP_SURFACE_TO_WINDOW_PDU));
+ RDPGFX_CMDID_MAPSURFACETOWINDOW,
+ sizeof(RDPGFX_MAP_SURFACE_TO_WINDOW_PDU));
if (!s)
{
Stream_Write_UINT64(s, pdu->windowId); /* windowId (8 bytes) */
Stream_Write_UINT32(s, pdu->mappedWidth); /* mappedWidth (4 bytes) */
Stream_Write_UINT32(s, pdu->mappedHeight); /* mappedHeight (4 bytes) */
-
return rdpgfx_server_single_packet_send(context, s);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_recv_frame_acknowledge_pdu(RdpgfxServerContext* context, wStream* s)
+static UINT rdpgfx_recv_frame_acknowledge_pdu(RdpgfxServerContext* context,
+ wStream* s)
{
RDPGFX_FRAME_ACKNOWLEDGE_PDU pdu;
UINT error = CHANNEL_RC_OK;
- if (Stream_GetRemainingLength(s) < sizeof(RDPGFX_FRAME_ACKNOWLEDGE_PDU))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) < sizeof(RDPGFX_FRAME_ACKNOWLEDGE_PDU))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
Stream_Read_UINT32(s, pdu.queueDepth); /* queueDepth (4 bytes) */
Stream_Read_UINT32(s, pdu.frameId); /* frameId (4 bytes) */
- Stream_Read_UINT32(s, pdu.totalFramesDecoded); /* totalFramesDecoded (4 bytes) */
+ /* totalFramesDecoded (4 bytes) */
+ Stream_Read_UINT32(s, pdu.totalFramesDecoded);
if (context)
{
IFCALLRET(context->FrameAcknowledge, error, context, &pdu);
+
if (error)
- WLog_ERR(TAG, "context->FrameAcknowledge failed with error %lu", error);
+ WLog_ERR(TAG, "context->FrameAcknowledge failed with error %lu",
+ error);
}
return error;
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_recv_cache_import_offer_pdu(RdpgfxServerContext* context, wStream* s)
+static UINT rdpgfx_recv_cache_import_offer_pdu(RdpgfxServerContext* context,
+ wStream* s)
{
UINT16 index;
RDPGFX_CACHE_IMPORT_OFFER_PDU pdu;
RDPGFX_CACHE_ENTRY_METADATA* cacheEntries;
UINT error = CHANNEL_RC_OK;
- if (Stream_GetRemainingLength(s) < sizeof(UINT16))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) < sizeof(UINT16))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
+
+ /* cacheEntriesCount (2 bytes) */
+ Stream_Read_UINT16(s, pdu.cacheEntriesCount);
- Stream_Read_UINT16(s, pdu.cacheEntriesCount); /* cacheEntriesCount (2 bytes) */
if (pdu.cacheEntriesCount <= 0)
{
/* According to the latest spec, capsSetCount <= 3 */
return ERROR_INVALID_DATA;
}
- if (Stream_GetRemainingLength(s) <
- (pdu.cacheEntriesCount * sizeof(RDPGFX_CACHE_ENTRY_METADATA)))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) <
+ (pdu.cacheEntriesCount * sizeof(RDPGFX_CACHE_ENTRY_METADATA)))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
- pdu.cacheEntries = (RDPGFX_CACHE_ENTRY_METADATA*)
- calloc(pdu.cacheEntriesCount,
- sizeof(RDPGFX_CACHE_ENTRY_METADATA));
+ pdu.cacheEntries = (RDPGFX_CACHE_ENTRY_METADATA*)
+ calloc(pdu.cacheEntriesCount,
+ sizeof(RDPGFX_CACHE_ENTRY_METADATA));
if (!pdu.cacheEntries)
{
{
cacheEntries = &(pdu.cacheEntries[index]);
Stream_Read_UINT64(s, cacheEntries->cacheKey); /* cacheKey (8 bytes) */
- Stream_Read_UINT32(s, cacheEntries->bitmapLength); /* bitmapLength (4 bytes) */
+ /* bitmapLength (4 bytes) */
+ Stream_Read_UINT32(s, cacheEntries->bitmapLength);
}
if (context)
{
IFCALLRET(context->CacheImportOffer, error, context, &pdu);
+
if (error)
- WLog_ERR(TAG, "context->CacheImportOffer failed with error %lu", error);
+ WLog_ERR(TAG, "context->CacheImportOffer failed with error %lu",
+ error);
}
free(pdu.cacheEntries);
-
return error;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_recv_caps_advertise_pdu(RdpgfxServerContext* context, wStream* s)
+static UINT rdpgfx_recv_caps_advertise_pdu(RdpgfxServerContext* context,
+ wStream* s)
{
UINT16 index;
RDPGFX_CAPSET* capsSet;
UINT error = CHANNEL_RC_OK;
UINT32 capsDataLength;
- if (Stream_GetRemainingLength(s) < sizeof(UINT16))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) < sizeof(UINT16))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
Stream_Read_UINT16(s, pdu.capsSetCount); /* capsSetCount (2 bytes) */
+
if (pdu.capsSetCount > 3)
{
/* According to the latest spec, capsSetCount <= 3 */
return ERROR_INVALID_DATA;
}
- if (Stream_GetRemainingLength(s) <
- (pdu.capsSetCount * (sizeof(RDPGFX_CAPSET) + sizeof(UINT32))))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) <
+ (pdu.capsSetCount * (sizeof(RDPGFX_CAPSET) + sizeof(UINT32))))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
pdu.capsSets = (RDPGFX_CAPSET*) capsSets;
capsSet = &(pdu.capsSets[index]);
Stream_Read_UINT32(s, capsSet->version); /* version (4 bytes) */
Stream_Read_UINT32(s, capsDataLength); /* capsDataLength (4 bytes) */
+
if (capsDataLength != 4)
{
- WLog_ERR(TAG, "capsDataLength does not equal to 4: %lu", capsDataLength);
+ WLog_ERR(TAG, "capsDataLength does not equal to 4: %lu",
+ capsDataLength);
return ERROR_INVALID_DATA;
}
+
Stream_Read_UINT32(s, capsSet->flags); /* capsData (4 bytes) */
}
if (context)
{
IFCALLRET(context->CapsAdvertise, error, context, &pdu);
+
if (error)
WLog_ERR(TAG, "context->CapsAdvertise failed with error %lu", error);
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-static UINT rdpgfx_recv_qoe_frame_acknowledge_pdu(RdpgfxServerContext* context, wStream* s)
+static UINT rdpgfx_recv_qoe_frame_acknowledge_pdu(RdpgfxServerContext* context,
+ wStream* s)
{
RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU pdu;
UINT error = CHANNEL_RC_OK;
- if (Stream_GetRemainingLength(s) < sizeof(RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU))
- {
- WLog_ERR(TAG, "not enough data!");
- return ERROR_INVALID_DATA;
- }
+ if (Stream_GetRemainingLength(s) < sizeof(RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU))
+ {
+ WLog_ERR(TAG, "not enough data!");
+ return ERROR_INVALID_DATA;
+ }
Stream_Read_UINT32(s, pdu.frameId); /* frameId (4 bytes) */
Stream_Read_UINT32(s, pdu.timestamp); /* timestamp (4 bytes) */
if (context)
{
IFCALLRET(context->QoeFrameAcknowledge, error, context, &pdu);
+
if (error)
- WLog_ERR(TAG, "context->QoeFrameAcknowledge failed with error %lu", error);
+ WLog_ERR(TAG, "context->QoeFrameAcknowledge failed with error %lu",
+ error);
}
return error;
int beg, end;
RDPGFX_HEADER header;
UINT error = CHANNEL_RC_OK;
-
beg = Stream_GetPosition(s);
if ((error = rdpgfx_read_header(s, &header)))
}
WLog_DBG(TAG, "cmdId: %s (0x%04X) flags: 0x%04X pduLength: %d",
- rdpgfx_get_cmd_id_string(header.cmdId), header.cmdId, header.flags, header.pduLength);
+ rdpgfx_get_cmd_id_string(header.cmdId), header.cmdId,
+ header.flags, header.pduLength);
switch (header.cmdId)
{
case RDPGFX_CMDID_FRAMEACKNOWLEDGE:
+
if ((error = rdpgfx_recv_frame_acknowledge_pdu(context, s)))
- WLog_ERR(TAG, "rdpgfx_recv_frame_acknowledge_pdu failed with error %lu!", error);
- break;
+ WLog_ERR(TAG, "rdpgfx_recv_frame_acknowledge_pdu "
+ "failed with error %lu!", error);
+ break;
case RDPGFX_CMDID_CACHEIMPORTOFFER:
+
if ((error = rdpgfx_recv_cache_import_offer_pdu(context, s)))
- WLog_ERR(TAG, "rdpgfx_recv_cache_import_offer_pdu failed with error %lu!", error);
- break;
+ WLog_ERR(TAG, "rdpgfx_recv_cache_import_offer_pdu "
+ "failed with error %lu!", error);
+ break;
case RDPGFX_CMDID_CAPSADVERTISE:
+
if ((error = rdpgfx_recv_caps_advertise_pdu(context, s)))
- WLog_ERR(TAG, "rdpgfx_recv_caps_advertise_pdu failed with error %lu!", error);
- break;
+ WLog_ERR(TAG, "rdpgfx_recv_caps_advertise_pdu "
+ "failed with error %lu!", error);
+ break;
case RDPGFX_CMDID_QOEFRAMEACKNOWLEDGE:
+
if ((error = rdpgfx_recv_qoe_frame_acknowledge_pdu(context, s)))
- WLog_ERR(TAG, "rdpgfx_recv_qoe_frame_acknowledge_pdu failed with error %lu!", error);
- break;
+ WLog_ERR(TAG, "rdpgfx_recv_qoe_frame_acknowledge_pdu "
+ "failed with error %lu!", error);
+ break;
default:
error = CHANNEL_RC_BAD_PROC;
break;
if (end != (beg + header.pduLength))
{
WLog_ERR(TAG, "Unexpected gfx pdu end: Actual: %d, Expected: %d",
- end, (beg + header.pduLength));
+ end, (beg + header.pduLength));
Stream_SetPosition(s, (beg + header.pduLength));
}
return error;
-
}
static void* rdpgfx_server_thread_func(void* arg)
{
RdpgfxServerContext* context = (RdpgfxServerContext*) arg;
RdpgfxServerPrivate* priv = context->priv;
- wStream* s;
DWORD status;
DWORD nCount;
void* buffer;
HANDLE events[8];
- HANDLE ChannelEvent;
DWORD BytesReturned = 0;
UINT error = CHANNEL_RC_OK;
- BOOL ready = FALSE;
-
buffer = NULL;
BytesReturned = 0;
- ChannelEvent = NULL;
-
- /* Query for channel event handle */
- if (WTSVirtualChannelQuery(priv->rdpgfx_channel, WTSVirtualEventHandle, &buffer, &BytesReturned) == TRUE)
- {
- if (BytesReturned == sizeof(HANDLE))
- CopyMemory(&ChannelEvent, buffer, sizeof(HANDLE));
-
- WTSFreeMemory(buffer);
- }
- else
- {
- WLog_ERR(TAG, "WTSVirtualChannelQuery failed");
- error = ERROR_INTERNAL_ERROR;
- goto out;
- }
-
nCount = 0;
events[nCount++] = priv->stopEvent;
- events[nCount++] = ChannelEvent;
-
- /* Wait for the client to confirm that the dynamic channel is ready */
- while (1)
- {
- if ((status = WaitForMultipleObjects(nCount, events, FALSE, 100)) == WAIT_OBJECT_0)
- goto out;
-
- if (status == WAIT_FAILED)
- {
- error = GetLastError();
- WLog_ERR(TAG, "WaitForMultipleObjects failed with error %lu", error);
- goto out;
- }
-
- if (WTSVirtualChannelQuery(priv->rdpgfx_channel, WTSVirtualChannelReady, &buffer, &BytesReturned) == FALSE)
- {
- WLog_ERR(TAG, "WTSVirtualChannelQuery failed");
- error = ERROR_INTERNAL_ERROR;
- goto out;
- }
-
- ready = *((BOOL*) buffer);
-
- WTSFreeMemory(buffer);
-
- if (ready)
- break;
- }
-
- /* Create shared stream */
- s = Stream_New(NULL, 4096);
- if (!s)
- {
- WLog_ERR(TAG, "Stream_New failed!");
- error = CHANNEL_RC_NO_MEMORY;
- goto out;
- }
+ events[nCount++] = priv->channelEvent;
/* Main virtual channel loop. RDPGFX do not need version negotiation */
- while (ready)
+ while (TRUE)
{
status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
{
error = GetLastError();
WLog_ERR(TAG, "WaitForMultipleObjects failed with error %lu", error);
- goto out;
- }
-
- /* Stop Event */
- if (status == WAIT_OBJECT_0)
- break;
-
- /* Channel Event */
- Stream_SetPosition(s, 0);
-
- if (!WTSVirtualChannelRead(priv->rdpgfx_channel, 0, NULL, 0, &BytesReturned))
- {
- WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
- error = ERROR_INTERNAL_ERROR;
- break;
- }
-
- if (BytesReturned < 1)
- continue;
-
- if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
- {
- WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
- error = CHANNEL_RC_NO_MEMORY;
break;
}
- if (WTSVirtualChannelRead(priv->rdpgfx_channel, 0, (PCHAR) Stream_Buffer(s),
- Stream_Capacity(s), &BytesReturned) == FALSE)
- {
- WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
- error = ERROR_INTERNAL_ERROR;
+ /* Stop Event */
+ if (status == WAIT_OBJECT_0)
break;
- }
- Stream_SetLength(s, BytesReturned);
- Stream_SetPosition(s, 0);
-
- while (((size_t) Stream_GetPosition(s)) < Stream_Length(s))
- {
- if ((error = rdpgfx_server_receive_pdu(context, s)))
- {
- WLog_ERR(TAG, "rdpgfx_server_receive_pdu failed with error %lu!", error);
- break;
- }
- }
-
- if (error != CHANNEL_RC_OK)
+ if ((error = rdpgfx_server_handle_messages(context)))
{
+ WLog_ERR(TAG, "rdpgfx_server_handle_messages failed with error %lu",
+ error);
break;
}
}
- Stream_Free(s, TRUE);
-out:
- WTSVirtualChannelClose(priv->rdpgfx_channel);
- priv->rdpgfx_channel = NULL;
if (error && context->rdpcontext)
- setChannelError(context->rdpcontext, error, "rdpgfx_server_thread_func reported an error");
+ setChannelError(context->rdpcontext, error,
+ "rdpgfx_server_thread_func reported an error");
ExitThread((DWORD)error);
return NULL;
static BOOL rdpgfx_server_open(RdpgfxServerContext* context)
{
- RdpgfxServerPrivate* priv = (RdpgfxServerPrivate *) context->priv;
+ RdpgfxServerPrivate* priv = (RdpgfxServerPrivate*) context->priv;
+ void* buffer = NULL;
- if (!priv->thread)
+ if (!priv->isOpened)
{
PULONG pSessionId = NULL;
DWORD BytesReturned = 0;
-
priv->SessionId = WTS_CURRENT_SESSION;
if (WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION,
- WTSSessionId, (LPSTR*) &pSessionId, &BytesReturned))
+ WTSSessionId, (LPSTR*) &pSessionId,
+ &BytesReturned) == FALSE)
{
- priv->SessionId = (DWORD) *pSessionId;
- WTSFreeMemory(pSessionId);
+ WLog_ERR(TAG, "WTSQuerySessionInformationA failed!");
+ return FALSE;
}
+ priv->SessionId = (DWORD) *pSessionId;
+ WTSFreeMemory(pSessionId);
priv->rdpgfx_channel = WTSVirtualChannelOpenEx(priv->SessionId,
- RDPGFX_DVC_CHANNEL_NAME, WTS_CHANNEL_OPTION_DYNAMIC);
+ RDPGFX_DVC_CHANNEL_NAME,
+ WTS_CHANNEL_OPTION_DYNAMIC);
if (!priv->rdpgfx_channel)
{
return FALSE;
}
- if (!(priv->zgfx = zgfx_context_new(TRUE)))
+ /* Query for channel event handle */
+ if (!WTSVirtualChannelQuery(priv->rdpgfx_channel, WTSVirtualEventHandle,
+ &buffer, &BytesReturned)
+ || (BytesReturned != sizeof(HANDLE)))
{
- WLog_ERR(TAG, "Create zgfx context failed!");
+ WLog_ERR(TAG, "WTSVirtualChannelQuery failed "
+ "or invalid returned size(%d)",
+ BytesReturned);
+
+ if (buffer)
+ WTSFreeMemory(buffer);
+
goto out_close;
}
- if (!(priv->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+ CopyMemory(&priv->channelEvent, buffer, sizeof(HANDLE));
+ WTSFreeMemory(buffer);
+
+ if (!(priv->zgfx = zgfx_context_new(TRUE)))
{
- WLog_ERR(TAG, "CreateEvent failed!");
- goto out_zgfx;
+ WLog_ERR(TAG, "Create zgfx context failed!");
+ goto out_close;
}
- if (!(priv->thread = CreateThread(NULL, 0,
- (LPTHREAD_START_ROUTINE) rdpgfx_server_thread_func, (void*) context, 0, NULL)))
+ if (priv->ownThread)
{
- WLog_ERR(TAG, "CreateThread failed!");
- goto out_stopEvent;
+ if (!(priv->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+ {
+ WLog_ERR(TAG, "CreateEvent failed!");
+ goto out_zgfx;
+ }
+
+ if (!(priv->thread = CreateThread(NULL, 0,
+ (LPTHREAD_START_ROUTINE)
+ rdpgfx_server_thread_func,
+ (void*) context, 0, NULL)))
+ {
+ WLog_ERR(TAG, "CreateThread failed!");
+ goto out_stopEvent;
+ }
}
+ priv->isOpened = TRUE;
+ priv->isReady = FALSE;
return TRUE;
}
- WLog_ERR(TAG, "thread already running!");
+ WLog_ERR(TAG, "RDPGFX channel is already opened!");
return FALSE;
-
out_stopEvent:
CloseHandle(priv->stopEvent);
priv->stopEvent = NULL;
-
out_zgfx:
zgfx_context_free(priv->zgfx);
priv->zgfx = NULL;
-
out_close:
WTSVirtualChannelClose(priv->rdpgfx_channel);
priv->rdpgfx_channel = NULL;
-
+ priv->channelEvent = NULL;
return FALSE;
}
static BOOL rdpgfx_server_close(RdpgfxServerContext* context)
{
- RdpgfxServerPrivate* priv = (RdpgfxServerPrivate *) context->priv;
+ RdpgfxServerPrivate* priv = (RdpgfxServerPrivate*) context->priv;
- if (priv->thread)
+ if (priv->ownThread && priv->thread)
{
SetEvent(priv->stopEvent);
+
if (WaitForSingleObject(priv->thread, INFINITE) == WAIT_FAILED)
{
- WLog_ERR(TAG, "WaitForSingleObject failed with error %lu", GetLastError());
+ WLog_ERR(TAG, "WaitForSingleObject failed with error %lu",
+ GetLastError());
return FALSE;
}
priv->rdpgfx_channel = NULL;
}
+ priv->channelEvent = NULL;
+ priv->isOpened = FALSE;
+ priv->isReady = FALSE;
return TRUE;
}
RdpgfxServerContext* rdpgfx_server_context_new(HANDLE vcm)
{
RdpgfxServerContext* context;
- RdpgfxServerPrivate *priv;
+ RdpgfxServerPrivate* priv;
+ context = (RdpgfxServerContext*)calloc(1, sizeof(RdpgfxServerContext));
- context = (RdpgfxServerContext *)calloc(1, sizeof(RdpgfxServerContext));
if (!context)
{
WLog_ERR(TAG, "calloc failed!");
context->vcm = vcm;
context->Open = rdpgfx_server_open;
context->Close = rdpgfx_server_close;
-
context->ResetGraphics = rdpgfx_send_reset_graphics_pdu;
context->StartFrame = rdpgfx_send_start_frame_pdu;
context->EndFrame = rdpgfx_send_end_frame_pdu;
context->CapsConfirm = rdpgfx_send_caps_confirm_pdu;
context->FrameAcknowledge = NULL;
context->QoeFrameAcknowledge = NULL;
+ context->priv = priv = (RdpgfxServerPrivate*)
+ calloc(1, sizeof(RdpgfxServerPrivate));
- context->priv = priv = (RdpgfxServerPrivate *)calloc(1, sizeof(RdpgfxServerPrivate));
if (!priv)
{
WLog_ERR(TAG, "calloc failed!");
goto out_free;
}
- return (RdpgfxServerContext*) context;
+ /* Create shared input stream */
+ priv->input_stream = Stream_New(NULL, 4);
+ if (!priv->input_stream)
+ {
+ WLog_ERR(TAG, "Stream_New failed!");
+ goto out_free_priv;
+ }
+
+ priv->isOpened = FALSE;
+ priv->isReady = FALSE;
+ priv->ownThread = TRUE;
+ return (RdpgfxServerContext*) context;
+out_free_priv:
+ free(context->priv);
out_free:
free(context);
return NULL;
{
rdpgfx_server_close(context);
- free(context->priv);
+ if (context->priv)
+ Stream_Free(context->priv->input_stream, TRUE);
+ free(context->priv);
free(context);
}
+
+FREERDP_API HANDLE rdpgfx_server_get_event_handle(RdpgfxServerContext* context)
+{
+ return context->priv->channelEvent;
+}
+
+/*
+ * Handle rpdgfx messages - server side
+ *
+ * @param Server side context
+ *
+ * @return 0 on success
+ * ERROR_NO_DATA if no data could be read this time
+ * otherwise a Win32 error code
+ */
+UINT rdpgfx_server_handle_messages(RdpgfxServerContext* context)
+{
+ DWORD BytesReturned;
+ void* buffer;
+ UINT ret = CHANNEL_RC_OK;
+ RdpgfxServerPrivate* priv = context->priv;
+ wStream* s = priv->input_stream;
+
+ /* Check whether the dynamic channel is ready */
+ if (!priv->isReady)
+ {
+ if (WTSVirtualChannelQuery(priv->rdpgfx_channel,
+ WTSVirtualChannelReady,
+ &buffer, &BytesReturned) == FALSE)
+ {
+ if (GetLastError() == ERROR_NO_DATA)
+ return ERROR_NO_DATA;
+
+ WLog_ERR(TAG, "WTSVirtualChannelQuery failed");
+ return ERROR_INTERNAL_ERROR;
+ }
+
+ priv->isReady = *((BOOL*) buffer);
+ WTSFreeMemory(buffer);
+ }
+
+ /* Consume channel event only after the gfx dynamic channel is ready */
+ if (priv->isReady)
+ {
+ Stream_SetPosition(s, 0);
+
+ if (!WTSVirtualChannelRead(priv->rdpgfx_channel,
+ 0, NULL, 0, &BytesReturned))
+ {
+ if (GetLastError() == ERROR_NO_DATA)
+ return ERROR_NO_DATA;
+
+ WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
+ return ERROR_INTERNAL_ERROR;
+ }
+
+ if (BytesReturned < 1)
+ return CHANNEL_RC_OK;
+
+ if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
+ {
+ WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
+ return CHANNEL_RC_NO_MEMORY;
+ }
+
+ if (WTSVirtualChannelRead(priv->rdpgfx_channel, 0,
+ (PCHAR) Stream_Buffer(s),
+ Stream_Capacity(s), &BytesReturned) == FALSE)
+ {
+ WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
+ return ERROR_INTERNAL_ERROR;
+ }
+
+ Stream_SetLength(s, BytesReturned);
+ Stream_SetPosition(s, 0);
+
+ while (((size_t) Stream_GetPosition(s)) < Stream_Length(s))
+ {
+ if ((ret = rdpgfx_server_receive_pdu(context, s)))
+ {
+ WLog_ERR(TAG, "rdpgfx_server_receive_pdu "
+ "failed with error %lu!", ret);
+ return ret;
+ }
+ }
+ }
+
+ return ret;
+}
projects / platform / upstream / freerdp.git / commitdiff