morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-14 00:14:11 +09:00
Code Issues Packages Projects Releases Wiki Activity

[libfreerdp] mark internal functions [[nodiscard]]

Browse Source
This commit is contained in:
Armin Novak
2026-02-24 11:28:38 +01:00
parent 6598081863
commit 4e4f84d33d
125 changed files with 1582 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
libfreerdp/cache/bitmap.h vendored
View File

@@ -33,12 +33,12 @@ typedef struct
typedef struct
{
pMemBlt MemBlt; /* 0 */
pMem3Blt Mem3Blt; /* 1 */
pCacheBitmap CacheBitmap; /* 2 */
pCacheBitmapV2 CacheBitmapV2; /* 3 */
pCacheBitmapV3 CacheBitmapV3; /* 4 */
pBitmapUpdate BitmapUpdate; /* 5 */
WINPR_ATTR_NODISCARD pMemBlt MemBlt; /* 0 */
WINPR_ATTR_NODISCARD pMem3Blt Mem3Blt; /* 1 */
WINPR_ATTR_NODISCARD pCacheBitmap CacheBitmap; /* 2 */
WINPR_ATTR_NODISCARD pCacheBitmapV2 CacheBitmapV2; /* 3 */
WINPR_ATTR_NODISCARD pCacheBitmapV3 CacheBitmapV3; /* 4 */
WINPR_ATTR_NODISCARD pBitmapUpdate BitmapUpdate; /* 5 */
UINT32 paddingA[16 - 6]; /* 6 */
UINT32 maxCells; /* 16 */

1
libfreerdp/cache/brush.h vendored
View File

@@ -34,6 +34,7 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL void* brush_cache_get(rdpBrushCache* brush, UINT32 index, UINT32* bpp);
FREERDP_LOCAL void brush_cache_put(rdpBrushCache* brush, UINT32 index, void* entry, UINT32 bpp);

28
libfreerdp/codec/bulk.c
View File

@@ -73,12 +73,12 @@ static inline const char* bulk_get_compression_flags_string(UINT32 flags)
}
#endif
WINPR_ATTR_NODISCARD
static UINT32 bulk_compression_level(rdpBulk* WINPR_RESTRICT bulk)
{
rdpSettings* settings = NULL;
WINPR_ASSERT(bulk);
WINPR_ASSERT(bulk->context);
settings = bulk->context->settings;
rdpSettings* settings = bulk->context->settings;
WINPR_ASSERT(settings);
bulk->CompressionLevel = (settings->CompressionLevel >= PACKET_COMPR_TYPE_RDP61)
? PACKET_COMPR_TYPE_RDP61
@@ -87,11 +87,15 @@ static UINT32 bulk_compression_level(rdpBulk* WINPR_RESTRICT bulk)
return bulk->CompressionLevel;
}
UINT16 bulk_compression_max_size(rdpBulk* WINPR_RESTRICT bulk)
static void bulk_update_compression_max_size(rdpBulk* WINPR_RESTRICT bulk)
{
WINPR_ASSERT(bulk);
(void)bulk_compression_level(bulk);
bulk->CompressionMaxSize = (bulk->CompressionLevel < PACKET_COMPR_TYPE_64K) ? 8192 : UINT16_MAX;
const UINT32 CompressionLevel = bulk_compression_level(bulk);
bulk->CompressionMaxSize = (CompressionLevel < PACKET_COMPR_TYPE_64K) ? 8192 : UINT16_MAX;
}
UINT16 bulk_compression_max_size(rdpBulk* WINPR_RESTRICT bulk)
{
bulk_update_compression_max_size(bulk);
return bulk->CompressionMaxSize;
}
@@ -162,7 +166,7 @@ int bulk_decompress(rdpBulk* WINPR_RESTRICT bulk, const BYTE* WINPR_RESTRICT pSr
rdpMetrics* metrics = bulk->context->metrics;
WINPR_ASSERT(metrics);
(void)bulk_compression_max_size(bulk);
bulk_update_compression_max_size(bulk);
const UINT32 type = flags & BULK_COMPRESSION_TYPE_MASK;
if (flags & BULK_COMPRESSION_FLAGS_MASK)
@@ -260,14 +264,14 @@ int bulk_compress(rdpBulk* WINPR_RESTRICT bulk, const BYTE* WINPR_RESTRICT pSrcD
}
*pDstSize = sizeof(bulk->OutputBuffer);
(void)bulk_compression_level(bulk);
(void)bulk_compression_max_size(bulk);
const UINT32 CompressionLevel = bulk_compression_level(bulk);
bulk_update_compression_max_size(bulk);
switch (bulk->CompressionLevel)
switch (CompressionLevel)
{
case PACKET_COMPR_TYPE_8K:
case PACKET_COMPR_TYPE_64K:
mppc_set_compression_level(bulk->mppcSend, bulk->CompressionLevel);
mppc_set_compression_level(bulk->mppcSend, CompressionLevel);
status = mppc_compress(bulk->mppcSend, pSrcData, SrcSize, bulk->OutputBuffer, ppDstData,
pDstSize, pFlags);
break;
@@ -280,11 +284,11 @@ int bulk_compress(rdpBulk* WINPR_RESTRICT bulk, const BYTE* WINPR_RESTRICT pSrcD
ppDstData, pDstSize, pFlags);
break;
case PACKET_COMPR_TYPE_RDP8:
WLog_ERR(TAG, "Unsupported bulk compression type %08" PRIx32, bulk->CompressionLevel);
WLog_ERR(TAG, "Unsupported bulk compression type %08" PRIx32, CompressionLevel);
status = -1;
break;
default:
WLog_ERR(TAG, "Unknown bulk compression type %08" PRIx32, bulk->CompressionLevel);
WLog_ERR(TAG, "Unknown bulk compression type %08" PRIx32, CompressionLevel);
status = -1;
break;
}

4
libfreerdp/codec/bulk.h
View File

@@ -28,11 +28,15 @@ typedef struct rdp_bulk rdpBulk;
#define BULK_COMPRESSION_FLAGS_MASK 0xE0
#define BULK_COMPRESSION_TYPE_MASK 0x0F
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT16 bulk_compression_max_size(rdpBulk* WINPR_RESTRICT bulk);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int bulk_decompress(rdpBulk* WINPR_RESTRICT bulk, const BYTE* WINPR_RESTRICT pSrcData,
UINT32 SrcSize, const BYTE** WINPR_RESTRICT ppDstData,
UINT32* WINPR_RESTRICT pDstSize, UINT32 flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int bulk_compress(rdpBulk* WINPR_RESTRICT bulk, const BYTE* WINPR_RESTRICT pSrcData,
UINT32 SrcSize, const BYTE** WINPR_RESTRICT ppDstData,
UINT32* WINPR_RESTRICT pDstSize, UINT32* WINPR_RESTRICT pFlags);

47
libfreerdp/codec/color.c
View File

@@ -330,9 +330,12 @@ BOOL freerdp_image_copy_from_monochrome(BYTE* WINPR_RESTRICT pDstData, UINT32 Ds
}
if (monoPixel)
FreeRDPWriteColor_int(pDstPixel, DstFormat, backColor);
else
FreeRDPWriteColor_int(pDstPixel, DstFormat, foreColor);
{
if (!FreeRDPWriteColor_int(pDstPixel, DstFormat, backColor))
return FALSE;
}
else if (!FreeRDPWriteColor_int(pDstPixel, DstFormat, foreColor))
return FALSE;
}
}
@@ -498,7 +501,8 @@ BOOL freerdp_image_copy_from_icon_data(BYTE* WINPR_RESTRICT pDstData, UINT32 Dst
UINT32 color = FreeRDPReadColor_int(dstBuf, DstFormat);
FreeRDPSplitColor(color, DstFormat, &r, &g, &b, NULL, &palette);
color = FreeRDPGetColor(DstFormat, r, g, b, alpha);
FreeRDPWriteColor_int(dstBuf, DstFormat, color);
if (!FreeRDPWriteColor_int(dstBuf, DstFormat, color))
return FALSE;
nextBit >>= 1;
dstBuf += dstBpp;
@@ -592,7 +596,8 @@ static BOOL freerdp_image_copy_from_pointer_data_1bpp(
else if (andPixel && xorPixel)
color = freerdp_image_inverted_pointer_color(x, y, DstFormat); /* inverted */
FreeRDPWriteColor_int(pDstPixel, DstFormat, color);
if (!FreeRDPWriteColor_int(pDstPixel, DstFormat, color))
return FALSE;
pDstPixel += FreeRDPGetBytesPerPixel(DstFormat);
}
}
@@ -730,7 +735,8 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(
}
color = FreeRDPConvertColor(xorPixel, PIXEL_FORMAT_ARGB32, DstFormat, palette);
FreeRDPWriteColor_int(pDstPixel, DstFormat, color);
if (!FreeRDPWriteColor_int(pDstPixel, DstFormat, color))
return FALSE;
pDstPixel += FreeRDPGetBytesPerPixel(DstFormat);
}
}
@@ -903,21 +909,25 @@ static inline BOOL freerdp_image_copy_generic(
UINT32 color = FreeRDPReadColor_int(&srcLine[nXSrc * srcByte], SrcFormat);
UINT32 oldColor = color;
UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
FreeRDPWriteColorIgnoreAlpha_int(&dstLine[nXDst * dstByte], DstFormat, dstColor);
if (!FreeRDPWriteColorIgnoreAlpha_int(&dstLine[nXDst * dstByte], DstFormat, dstColor))
return FALSE;
for (int64_t x = 1; x < nWidth; x++)
{
color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
if (color == oldColor)
{
FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor);
if (!FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor))
return FALSE;
}
else
{
oldColor = color;
dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor);
if (!FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor))
return FALSE;
}
}
}
@@ -1077,19 +1087,25 @@ BOOL freerdp_image_copy_overlap(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep
UINT32 color = FreeRDPReadColor_int(&srcLine[1ULL * nXSrc * srcByte], SrcFormat);
UINT32 oldColor = color;
UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
FreeRDPWriteColor_int(&dstLine[1ULL * nXDst * dstByte], DstFormat, dstColor);
if (!FreeRDPWriteColor_int(&dstLine[1ULL * nXDst * dstByte], DstFormat, dstColor))
return FALSE;
for (int64_t x = 1; x < nWidth; x++)
{
color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
if (color == oldColor)
{
FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
if (!FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor))
return FALSE;
}
else
{
oldColor = color;
dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
if (!FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
dstColor))
return FALSE;
}
}
}
@@ -1146,7 +1162,8 @@ BOOL freerdp_image_fill(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 n
for (size_t x = 0; x < nWidth; x++)
{
BYTE* pDst = &pFirstDstLine[(x + nXDst) * bpp];
FreeRDPWriteColor_int(pDst, DstFormat, color);
if (!FreeRDPWriteColor_int(pDst, DstFormat, color))
return FALSE;
}
for (size_t y = 1; y < nHeight; y++)

4
libfreerdp/codec/color.h
View File

@@ -28,12 +28,14 @@
#define INT_COLOR_TAG FREERDP_TAG("codec.color.h")
WINPR_ATTR_NODISCARD
static inline DWORD FreeRDPAreColorFormatsEqualNoAlpha_int(DWORD first, DWORD second)
{
const DWORD mask = (DWORD) ~(8UL << 12UL);
return (first & mask) == (second & mask);
}
WINPR_ATTR_NODISCARD
static inline BOOL FreeRDPWriteColor_int(BYTE* WINPR_RESTRICT dst, UINT32 format, UINT32 color)
{
switch (FreeRDPGetBitsPerPixel(format))
@@ -76,6 +78,7 @@ static inline BOOL FreeRDPWriteColor_int(BYTE* WINPR_RESTRICT dst, UINT32 format
return TRUE;
}
WINPR_ATTR_NODISCARD
static inline BOOL FreeRDPWriteColorIgnoreAlpha_int(BYTE* WINPR_RESTRICT dst, UINT32 format,
UINT32 color)
{
@@ -102,6 +105,7 @@ static inline BOOL FreeRDPWriteColorIgnoreAlpha_int(BYTE* WINPR_RESTRICT dst, UI
}
}
WINPR_ATTR_NODISCARD
static inline UINT32 FreeRDPReadColor_int(const BYTE* WINPR_RESTRICT src, UINT32 format)
{
UINT32 color = 0;

7
libfreerdp/codec/dsp.h
View File

@@ -40,7 +40,10 @@ typedef struct
#endif
} FREERDP_DSP_COMMON_CONTEXT;
BOOL freerdp_dsp_common_context_init(FREERDP_DSP_COMMON_CONTEXT* context, BOOL encode);
void freerdp_dsp_common_context_uninit(FREERDP_DSP_COMMON_CONTEXT* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_dsp_common_context_init(FREERDP_DSP_COMMON_CONTEXT* context,
BOOL encode);
FREERDP_LOCAL void freerdp_dsp_common_context_uninit(FREERDP_DSP_COMMON_CONTEXT* context);
#endif /* FREERDP_LIB_CODEC_DSP_H */

17
libfreerdp/codec/dsp_fdk_aac.h
View File

@@ -26,13 +26,20 @@
#include "dsp.h"
BOOL fdk_aac_dsp_init(FREERDP_DSP_COMMON_CONTEXT* context, size_t frames_per_packet);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL fdk_aac_dsp_init(FREERDP_DSP_COMMON_CONTEXT* context,
size_t frames_per_packet);
FREERDP_LOCAL
void fdk_aac_dsp_uninit(FREERDP_DSP_COMMON_CONTEXT* context);
BOOL fdk_aac_dsp_encode(FREERDP_DSP_COMMON_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length, wStream* out);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL fdk_aac_dsp_encode(FREERDP_DSP_COMMON_CONTEXT* context,
const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length,
wStream* out);
BOOL fdk_aac_dsp_decode(FREERDP_DSP_COMMON_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length, wStream* out);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL fdk_aac_dsp_decode(FREERDP_DSP_COMMON_CONTEXT* context,
const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length,
wStream* out);
#endif

25
libfreerdp/codec/dsp_ffmpeg.h
View File

@@ -32,19 +32,26 @@
"DSP module requires libavcodec version >= 57.48.101. Upgrade or set WITH_DSP_FFMPEG=OFF to continue"
#endif
void freerdp_dsp_ffmpeg_context_free(FREERDP_DSP_CONTEXT* context);
FREERDP_LOCAL void freerdp_dsp_ffmpeg_context_free(FREERDP_DSP_CONTEXT* context);
WINPR_ATTR_MALLOC(freerdp_dsp_ffmpeg_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_DSP_CONTEXT* freerdp_dsp_ffmpeg_context_new(BOOL encode);
FREERDP_LOCAL FREERDP_DSP_CONTEXT* freerdp_dsp_ffmpeg_context_new(BOOL encode);
BOOL freerdp_dsp_ffmpeg_supports_format(const AUDIO_FORMAT* format, BOOL encode);
BOOL freerdp_dsp_ffmpeg_encode(FREERDP_DSP_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length, wStream* out);
BOOL freerdp_dsp_ffmpeg_decode(FREERDP_DSP_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length, wStream* out);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL
freerdp_dsp_ffmpeg_supports_format(const AUDIO_FORMAT* format, BOOL encode);
BOOL freerdp_dsp_ffmpeg_context_reset(FREERDP_DSP_CONTEXT* context,
const AUDIO_FORMAT* targetFormat);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL freerdp_dsp_ffmpeg_encode(FREERDP_DSP_CONTEXT* context,
const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length,
wStream* out);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL freerdp_dsp_ffmpeg_decode(FREERDP_DSP_CONTEXT* context,
const AUDIO_FORMAT* srcFormat,
const BYTE* data, size_t length,
wStream* out);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL
freerdp_dsp_ffmpeg_context_reset(FREERDP_DSP_CONTEXT* context, const AUDIO_FORMAT* targetFormat);
#endif /* FREERDP_LIB_CODEC_DSP_FFMPEG_H */

1
libfreerdp/codec/h264.h
View File

@@ -87,6 +87,7 @@ extern "C"
wLog* log;
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL avc420_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width,
UINT32 height);

3
libfreerdp/codec/include/bitmap.h
View File

@@ -28,6 +28,7 @@
/**
* Write a foreground/background image to a destination buffer.
*/
WINPR_ATTR_NODISCARD
static inline BYTE* WRITEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
const BYTE* WINPR_RESTRICT pbDestEnd, UINT32 rowDelta,
BYTE bitmask, PIXEL fgPel, UINT32 cBits)
@@ -63,6 +64,7 @@ static inline BYTE* WRITEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
* Write a foreground/background image to a destination buffer
* for the first line of compressed data.
*/
WINPR_ATTR_NODISCARD
static inline BYTE* WRITEFIRSTLINEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
const BYTE* WINPR_RESTRICT pbDestEnd, BYTE bitmask,
PIXEL fgPel, UINT32 cBits)
@@ -95,6 +97,7 @@ static inline BYTE* WRITEFIRSTLINEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
/**
* Decompress an RLE compressed bitmap.
*/
WINPR_ATTR_NODISCARD
static inline BOOL RLEDECOMPRESS(const BYTE* WINPR_RESTRICT pbSrcBuffer, UINT32 cbSrcBuffer,
BYTE* WINPR_RESTRICT pbDestBuffer, UINT32 rowDelta, UINT32 width,
UINT32 height)

8
libfreerdp/codec/mppc.h
View File

@@ -34,9 +34,12 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int mppc_compress(MPPC_CONTEXT* mppc, const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstBuffer, const BYTE** ppDstData, UINT32* pDstSize,
UINT32* pFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int mppc_decompress(MPPC_CONTEXT* mppc, const BYTE* pSrcData, UINT32 SrcSize,
const BYTE** ppDstData, UINT32* pDstSize, UINT32 flags);
@@ -44,9 +47,12 @@ extern "C"
FREERDP_LOCAL void mppc_context_reset(MPPC_CONTEXT* mppc, BOOL flush);
FREERDP_LOCAL MPPC_CONTEXT* mppc_context_new(DWORD CompressionLevel, BOOL Compressor);
FREERDP_LOCAL void mppc_context_free(MPPC_CONTEXT* mppc);
WINPR_ATTR_MALLOC(mppc_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL MPPC_CONTEXT* mppc_context_new(DWORD CompressionLevel, BOOL Compressor);
#ifdef __cplusplus
}
#endif

7
libfreerdp/codec/ncrush.h
View File

@@ -34,18 +34,23 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int ncrush_compress(NCRUSH_CONTEXT* ncrush, const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstBuffer, const BYTE** ppDstData, UINT32* pDstSize,
UINT32* pFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int ncrush_decompress(NCRUSH_CONTEXT* ncrush, const BYTE* pSrcData,
UINT32 SrcSize, const BYTE** ppDstData, UINT32* pDstSize,
UINT32 flags);
FREERDP_LOCAL void ncrush_context_reset(NCRUSH_CONTEXT* ncrush, BOOL flush);
FREERDP_LOCAL NCRUSH_CONTEXT* ncrush_context_new(BOOL Compressor);
FREERDP_LOCAL void ncrush_context_free(NCRUSH_CONTEXT* ncrush);
WINPR_ATTR_MALLOC(ncrush_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL NCRUSH_CONTEXT* ncrush_context_new(BOOL Compressor);
#ifdef __cplusplus
}
#endif

3
libfreerdp/codec/nsc_encode.h
View File

@@ -22,8 +22,11 @@
#ifndef FREERDP_LIB_CODEC_NSC_ENCODE_H
#define FREERDP_LIB_CODEC_NSC_ENCODE_H
#include <winpr/wtypes.h>
#include <freerdp/api.h>
#include <freerdp/codec/nsc.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nsc_encode(NSC_CONTEXT* WINPR_RESTRICT context,
const BYTE* WINPR_RESTRICT bmpdata, UINT32 rowstride);

6
libfreerdp/codec/nsc_types.h
View File

@@ -71,9 +71,9 @@ struct S_NSC_CONTEXT
/* color palette allocated by the application */
const BYTE* palette;
BOOL (*decode)(NSC_CONTEXT* WINPR_RESTRICT context);
BOOL(*encode)
(NSC_CONTEXT* WINPR_RESTRICT context, const BYTE* WINPR_RESTRICT BitmapData, UINT32 rowstride);
WINPR_ATTR_NODISCARD BOOL (*decode)(NSC_CONTEXT* WINPR_RESTRICT context);
WINPR_ATTR_NODISCARD BOOL (*encode)(NSC_CONTEXT* WINPR_RESTRICT context,
const BYTE* WINPR_RESTRICT BitmapData, UINT32 rowstride);
NSC_CONTEXT_PRIV* priv;
};

21
libfreerdp/codec/rfx.c
View File

@@ -780,7 +780,11 @@ rfx_process_message_tile_work_callback(WINPR_ATTR_UNUSED PTP_CALLBACK_INSTANCE i
{
RFX_TILE_PROCESS_WORK_PARAM* param = (RFX_TILE_PROCESS_WORK_PARAM*)context;
WINPR_ASSERT(param);
rfx_decode_rgb(param->context, param->tile, param->tile->data, 64 * 4);
WINPR_ASSERT(param->context);
WINPR_ASSERT(param->context->priv);
if (!rfx_decode_rgb(param->context, param->tile, param->tile->data, 64 * 4))
WLog_Print(param->context->priv->log, WLOG_ERROR, "rfx_decode_rgb failed");
}
static inline BOOL rfx_allocate_tiles(RFX_MESSAGE* WINPR_RESTRICT message, size_t count,
@@ -1073,7 +1077,11 @@ static inline BOOL rfx_process_message_tileset(RFX_CONTEXT* WINPR_RESTRICT conte
}
else
{
rfx_decode_rgb(context, tile, tile->data, 64 * 4);
if (!rfx_decode_rgb(context, tile, tile->data, 64 * 4))
{
rc = FALSE;
break;
}
}
}
}
@@ -1581,7 +1589,11 @@ rfx_compose_message_tile_work_callback(WINPR_ATTR_UNUSED PTP_CALLBACK_INSTANCE i
{
RFX_TILE_COMPOSE_WORK_PARAM* param = (RFX_TILE_COMPOSE_WORK_PARAM*)context;
WINPR_ASSERT(param);
rfx_encode_rgb(param->context, param->tile);
WINPR_ASSERT(param->context);
WINPR_ASSERT(param->context->priv);
if (!rfx_encode_rgb(param->context, param->tile))
WLog_Print(param->context->priv->log, WLOG_ERROR, "rfx_encode_rgb failed");
}
static inline BOOL computeRegion(const RFX_RECT* WINPR_RESTRICT rects, size_t numRects,
@@ -1838,7 +1850,8 @@ RFX_MESSAGE* rfx_encode_message(RFX_CONTEXT* WINPR_RESTRICT context,
}
else
{
rfx_encode_rgb(context, tile);
if (!rfx_encode_rgb(context, tile))
goto skip_encoding_loop;
}
if (!region16_union_rect(&tilesRegion, &tilesRegion, &currentTileRect))

4
libfreerdp/codec/rfx_bitstream.h
View File

@@ -50,6 +50,7 @@ extern "C"
bs->bits_left = 8;
}
WINPR_ATTR_NODISCARD
static inline uint32_t rfx_bitstream_get_bits(RFX_BITSTREAM* bs, uint32_t nbits)
{
UINT16 n = 0;
@@ -104,12 +105,14 @@ extern "C"
}
}
WINPR_ATTR_NODISCARD
static inline BOOL rfx_bitstream_eos(RFX_BITSTREAM* bs)
{
WINPR_ASSERT(bs);
return ((bs)->byte_pos >= (bs)->nbytes);
}
WINPR_ATTR_NODISCARD
static inline uint32_t rfx_bitstream_left(RFX_BITSTREAM* bs)
{
WINPR_ASSERT(bs);
@@ -120,6 +123,7 @@ extern "C"
return ((bs)->nbytes - (bs)->byte_pos - 1) * 8 + (bs)->bits_left;
}
WINPR_ATTR_NODISCARD
static inline uint32_t rfx_bitstream_get_processed_bytes(RFX_BITSTREAM* bs)
{
WINPR_ASSERT(bs);

1
libfreerdp/codec/rfx_constants.h
View File

@@ -72,6 +72,7 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rfx_get_progressive_block_type_string(UINT16 blockType);
#ifdef __cplusplus

13
libfreerdp/codec/rfx_decode.c
View File

@@ -40,12 +40,19 @@ static inline void rfx_decode_component(RFX_CONTEXT* WINPR_RESTRICT context,
const BYTE* WINPR_RESTRICT data, size_t size,
INT16* WINPR_RESTRICT buffer)
{
INT16* dwt_buffer = NULL;
dwt_buffer = BufferPool_Take(context->priv->BufferPool, -1); /* dwt_buffer */
INT16* dwt_buffer = BufferPool_Take(context->priv->BufferPool, -1); /* dwt_buffer */
WINPR_ASSERT(dwt_buffer);
PROFILER_ENTER(context->priv->prof_rfx_decode_component)
PROFILER_ENTER(context->priv->prof_rfx_rlgr_decode)
WINPR_ASSERT(size <= UINT32_MAX);
context->rlgr_decode(context->mode, data, (UINT32)size, buffer, 4096);
{
const int rc = context->rlgr_decode(context->mode, data, (UINT32)size, buffer, 4096);
if (rc < 0)
WLog_Print(context->priv->log, WLOG_ERROR, "context->rlgr_decode failed: %d", rc);
}
PROFILER_EXIT(context->priv->prof_rfx_rlgr_decode)
PROFILER_ENTER(context->priv->prof_rfx_differential_decode)
rfx_differential_decode(buffer + 4032, 64);

1
libfreerdp/codec/rfx_decode.h
View File

@@ -26,6 +26,7 @@
#include <freerdp/api.h>
/* stride is bytes between rows in the output buffer. */
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rfx_decode_rgb(RFX_CONTEXT* WINPR_RESTRICT context,
const RFX_TILE* WINPR_RESTRICT tile,
BYTE* WINPR_RESTRICT rgb_buffer, UINT32 stride);

1
libfreerdp/codec/rfx_encode.h
View File

@@ -23,6 +23,7 @@
#include <freerdp/codec/rfx.h>
#include <freerdp/api.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rfx_encode_rgb(RFX_CONTEXT* WINPR_RESTRICT context,
RFX_TILE* WINPR_RESTRICT tile);

2
libfreerdp/codec/rfx_rlgr.h
View File

@@ -23,10 +23,12 @@
#include <freerdp/codec/rfx.h>
#include <freerdp/api.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rfx_rlgr_encode(RLGR_MODE mode, const INT16* WINPR_RESTRICT data,
UINT32 data_size, BYTE* WINPR_RESTRICT buffer,
UINT32 buffer_size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rfx_rlgr_decode(RLGR_MODE mode, const BYTE* WINPR_RESTRICT pSrcData,
UINT32 SrcSize, INT16* WINPR_RESTRICT pDstData, UINT32 rDstSize);

10
libfreerdp/codec/rfx_types.h
View File

@@ -166,10 +166,12 @@ struct S_RFX_CONTEXT
void (*dwt_2d_decode)(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer);
void (*dwt_2d_extrapolate_decode)(INT16* WINPR_RESTRICT src, INT16* WINPR_RESTRICT temp);
void (*dwt_2d_encode)(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer);
int (*rlgr_decode)(RLGR_MODE mode, const BYTE* WINPR_RESTRICT data, UINT32 data_size,
INT16* WINPR_RESTRICT buffer, UINT32 buffer_size);
int (*rlgr_encode)(RLGR_MODE mode, const INT16* WINPR_RESTRICT data, UINT32 data_size,
BYTE* WINPR_RESTRICT buffer, UINT32 buffer_size);
WINPR_ATTR_NODISCARD int (*rlgr_decode)(RLGR_MODE mode, const BYTE* WINPR_RESTRICT data,
UINT32 data_size, INT16* WINPR_RESTRICT buffer,
UINT32 buffer_size);
WINPR_ATTR_NODISCARD int (*rlgr_encode)(RLGR_MODE mode, const INT16* WINPR_RESTRICT data,
UINT32 data_size, BYTE* WINPR_RESTRICT buffer,
UINT32 buffer_size);
/* private definitions */
RFX_CONTEXT_PRIV* priv;

8
libfreerdp/codec/xcrush.h
View File

@@ -32,12 +32,15 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int xcrush_compress(XCRUSH_CONTEXT* WINPR_RESTRICT xcrush,
const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
BYTE* WINPR_RESTRICT pDstBuffer,
const BYTE** WINPR_RESTRICT ppDstData,
UINT32* WINPR_RESTRICT pDstSize,
UINT32* WINPR_RESTRICT pFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int xcrush_decompress(XCRUSH_CONTEXT* WINPR_RESTRICT xcrush,
const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
const BYTE** WINPR_RESTRICT ppDstData,
@@ -45,9 +48,12 @@ extern "C"
FREERDP_LOCAL void xcrush_context_reset(XCRUSH_CONTEXT* WINPR_RESTRICT xcrush, BOOL flush);
FREERDP_LOCAL XCRUSH_CONTEXT* xcrush_context_new(BOOL Compressor);
FREERDP_LOCAL void xcrush_context_free(XCRUSH_CONTEXT* xcrush);
WINPR_ATTR_MALLOC(xcrush_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL XCRUSH_CONTEXT* xcrush_context_new(BOOL Compressor);
#ifdef __cplusplus
}
#endif

5
libfreerdp/core/aad.h
View File

@@ -32,11 +32,16 @@ typedef enum
#include <freerdp/api.h>
#include <freerdp/freerdp.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL aad_is_supported(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int aad_client_begin(rdpAad* aad);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int aad_recv(rdpAad* aad, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL AAD_STATE aad_get_state(rdpAad* aad);
FREERDP_LOCAL void aad_free(rdpAad* aad);

30
libfreerdp/core/activation.h
View File

@@ -58,25 +58,55 @@ typedef struct
#define FONTLIST_FIRST 0x0001
#define FONTLIST_LAST 0x0002
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rdp_ctrlaction_string(UINT16 action, char* buffer, size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_deactivate_all(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_server_synchronize_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_server_synchronize_pdu(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_client_synchronize_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_client_synchronize_pdu(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_server_control_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_server_control_cooperate_pdu(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_client_control_pdu(rdpRdp* rdp, UINT16 action);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_server_control_granted_pdu(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_client_font_list_pdu(rdpRdp* rdp, UINT16 flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_font_map_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_client_control_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_client_font_list_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_client_persistent_key_list_pdu(rdpRdp* rdp, wStream* s);
#endif /* FREERDP_LIB_CORE_ACTIVATION_H */

4
libfreerdp/core/autodetect.h
View File

@@ -38,11 +38,15 @@ WINPR_ATTR_MALLOC(autodetect_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpAutoDetect* autodetect_new(rdpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t autodetect_recv_request_packet(rdpAutoDetect* autodetect,
RDP_TRANSPORT_TYPE transport, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t autodetect_recv_response_packet(rdpAutoDetect* autodetect,
RDP_TRANSPORT_TYPE transport, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL FREERDP_AUTODETECT_STATE autodetect_get_state(rdpAutoDetect* autodetect);
FREERDP_LOCAL void autodetect_register_server_callbacks(rdpAutoDetect* autodetect);

11
libfreerdp/core/capabilities.h
View File

@@ -153,16 +153,27 @@
#define CLW_ENTROPY_RLGR1 0x01
#define CLW_ENTROPY_RLGR3 0x04
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_get_active_header(rdpRdp* rdp, wStream* s, UINT16* pChannelId,
UINT16* length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_demand_active(rdpRdp* rdp, wStream* s, UINT16 pduSource, UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_demand_active(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_confirm_active(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_capability_set(wLog* log, wStream* sub, UINT16 type,
rdpSettings* settings, BOOL isServer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rdp_input_flag_string(UINT16 flags, char* buffer, size_t len);
#endif /* FREERDP_LIB_CORE_CAPABILITIES_H */

7
libfreerdp/core/channels.h
View File

@@ -23,12 +23,19 @@
#include <freerdp/api.h>
#include "client.h"
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_channel_send(rdpRdp* rdp, UINT16 channelId, const BYTE* data,
size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize,
UINT32 flags, const BYTE* data, size_t chunkSize);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_channel_process(freerdp* instance, wStream* s, UINT16 channelId,
size_t packetLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 channelId);
#endif /* FREERDP_LIB_CORE_CHANNELS_H */

4
libfreerdp/core/childsession.h
View File

@@ -20,8 +20,12 @@
#ifndef FREERDP_LIB_CORE_CHILDSESSION_H
#define FREERDP_LIB_CORE_CHILDSESSION_H
#include <winpr/wtypes.h>
#include <freerdp/api.h>
#include <openssl/bio.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO* createChildSessionBio(void);
#endif /* FREERDP_LIB_CORE_CHILDSESSION_H */

10
libfreerdp/core/client.h
View File

@@ -42,8 +42,8 @@
typedef struct
{
PVIRTUALCHANNELENTRY entry;
PVIRTUALCHANNELENTRYEX entryEx;
WINPR_ATTR_NODISCARD PVIRTUALCHANNELENTRY entry;
WINPR_ATTR_NODISCARD PVIRTUALCHANNELENTRYEX entryEx;
PCHANNEL_INIT_EVENT_FN pChannelInitEventProc;
PCHANNEL_INIT_EVENT_EX_FN pChannelInitEventProcEx;
void* pInitHandle;
@@ -118,13 +118,19 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpChannels* freerdp_channels_new(freerdp* instance);
FREERDP_LOCAL UINT freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance);
FREERDP_LOCAL void freerdp_channels_close(rdpChannels* channels, freerdp* instance);
FREERDP_LOCAL void freerdp_channels_register_instance(rdpChannels* channels, freerdp* instance);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT freerdp_channels_pre_connect(rdpChannels* channels, freerdp* instance);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance);
/** @since version 3.9.0 */
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T freerdp_client_channel_get_registered_event_handles(rdpChannels* channels,
HANDLE* events,
DWORD count);

15
libfreerdp/core/connection.c
View File

@@ -462,7 +462,8 @@ BOOL rdp_client_connect(rdpRdp* rdp)
return FALSE;
}
transport_set_blocking_mode(rdp->transport, FALSE);
if (!transport_set_blocking_mode(rdp->transport, FALSE))
return FALSE;
}
else
{
@@ -762,8 +763,9 @@ static BOOL rdp_client_establish_keys(rdpRdp* rdp)
if (!crypt_client_random)
return FALSE;
crypto_rsa_public_encrypt(settings->ClientRandom, settings->ClientRandomLength, info,
crypt_client_random, info->ModulusLength);
if (crypto_rsa_public_encrypt(settings->ClientRandom, settings->ClientRandomLength, info,
crypt_client_random, info->ModulusLength) < 0)
return FALSE;
/* send crypt client random to server */
const size_t length = RDP_PACKET_HEADER_MAX_LENGTH + RDP_SECURITY_HEADER_LENGTH + 4ULL +
info->ModulusLength + 8ULL;
@@ -1451,7 +1453,8 @@ BOOL rdp_server_accept_nego(rdpRdp* rdp, wStream* s)
nego = rdp->nego;
WINPR_ASSERT(nego);
transport_set_blocking_mode(rdp->transport, TRUE);
if (!transport_set_blocking_mode(rdp->transport, TRUE))
return FALSE;
if (!nego_read_request(nego, s))
return FALSE;
@@ -1547,9 +1550,7 @@ BOOL rdp_server_accept_nego(rdpRdp* rdp, wStream* s)
if (!status)
return FALSE;
transport_set_blocking_mode(rdp->transport, FALSE);
return TRUE;
return transport_set_blocking_mode(rdp->transport, FALSE);
}
static BOOL rdp_update_encryption_level(rdpSettings* settings)

52
libfreerdp/core/connection.h
View File

@@ -38,43 +38,95 @@ enum CLIENT_CONNECTION_STATE
CLIENT_STATE_POSTCONNECT_PASSED
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_connect(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_disconnect(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_disconnect_and_clear(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_reconnect(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_redirect(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_skip_mcs_channel_join(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_connect_auto_detect(rdpRdp* rdp, wStream* s, DWORD logLevel);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_client_connect_license(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_client_connect_confirm_active(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_client_connect_finalize(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_client_transition_to_state(rdpRdp* rdp, CONNECTION_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL CONNECTION_STATE rdp_get_state(const rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rdp_state_string(CONNECTION_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_is_active_state(const rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_nego(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_mcs_connect_initial(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_mcs_erect_domain_request(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_mcs_attach_user_request(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_mcs_channel_join_request(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_accept_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_establish_keys(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_reactivate(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_server_transition_to_state(rdpRdp* rdp, CONNECTION_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rdp_get_state_string(const rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rdp_client_connection_state_string(UINT state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_channels_from_mcs(rdpSettings* settings, const rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_handle_message_channel(rdpRdp* rdp, wStream* s, UINT16 channelId,
UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_handle_optional_rdp_decryption(rdpRdp* rdp, wStream* s, UINT16* length,
UINT16* pSecurityFlags);

31
libfreerdp/core/credssp_auth.h
View File

@@ -38,30 +38,61 @@ WINPR_ATTR_MALLOC(credssp_auth_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpCredsspAuth* credssp_auth_new(const rdpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_init(rdpCredsspAuth* auth, TCHAR* pkg_name,
SecPkgContext_Bindings* bindings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_setup_client(rdpCredsspAuth* auth, const char* target_service,
const char* target_hostname,
const SEC_WINNT_AUTH_IDENTITY* identity,
const char* pkinit);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_setup_server(rdpCredsspAuth* auth);
FREERDP_LOCAL void credssp_auth_set_flags(rdpCredsspAuth* auth, ULONG flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int credssp_auth_authenticate(rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_encrypt(rdpCredsspAuth* auth, const SecBuffer* plaintext,
SecBuffer* ciphertext, size_t* signature_length,
ULONG sequence);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_decrypt(rdpCredsspAuth* auth, const SecBuffer* ciphertext,
SecBuffer* plaintext, ULONG sequence);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_impersonate(rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_revert_to_self(rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_set_spn(rdpCredsspAuth* auth, const char* service,
const char* hostname);
FREERDP_LOCAL void credssp_auth_take_input_buffer(rdpCredsspAuth* auth, SecBuffer* buffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const SecBuffer* credssp_auth_get_output_buffer(const rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_have_output_token(rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL credssp_auth_is_complete(const rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* credssp_auth_pkg_name(const rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t credssp_auth_trailer_size(const rdpCredsspAuth* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL INT32 credssp_auth_sspi_error(const rdpCredsspAuth* auth);
FREERDP_LOCAL void credssp_auth_tableAndContext(rdpCredsspAuth* auth,

1
libfreerdp/core/display.h
View File

@@ -23,6 +23,7 @@
#include <freerdp/display.h>
#include "rdp.h"
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL display_convert_rdp_monitor_to_monitor_def(UINT32 monitorCount,
const rdpMonitor* monitorDefArray,
MONITOR_DEF** result);

15
libfreerdp/core/fastpath.c
View File

@@ -1070,8 +1070,7 @@ BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s, size_t
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
goto fail;
security_lock(rdp);
should_unlock = TRUE;
const size_t sec_bytes = fastpath_get_sec_bytes(fastpath->rdp);
@@ -1143,8 +1142,8 @@ BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s, size_t
rc = TRUE;
fail:
if (should_unlock && !security_unlock(rdp))
rc = FALSE;
if (should_unlock)
security_unlock(rdp);
Stream_Release(s);
return rc;
}
@@ -1325,8 +1324,8 @@ BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s
BOOL res = FALSE;
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
return FALSE;
security_lock(rdp);
should_unlock = TRUE;
UINT32 dataSize = fpUpdateHeaderSize + DstSize + pad;
BYTE* data = Stream_PointerAs(fs, BYTE) - dataSize;
@@ -1363,8 +1362,8 @@ BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s
}
unlock:
if (should_unlock && !security_unlock(rdp))
return FALSE;
if (should_unlock)
security_unlock(rdp);
if (!res || !status)
return FALSE;

25
libfreerdp/core/fastpath.h
View File

@@ -126,17 +126,32 @@ typedef struct
BYTE compression;
} FASTPATH_UPDATE_HEADER;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_read_header_rdp(rdpFastPath* fastpath, wStream* s, UINT16* length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t fastpath_recv_updates(rdpFastPath* fastpath, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t fastpath_recv_inputs(rdpFastPath* fastpath, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_decrypt(rdpFastPath* fastpath, wStream* s, UINT16* length);
WINPR_ATTR_MALLOC(Stream_Release, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* fastpath_input_pdu_init_header(rdpFastPath* fastpath, UINT16* sec_flags);
WINPR_ATTR_MALLOC(Stream_Release, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* fastpath_input_pdu_init(rdpFastPath* fastpath, BYTE eventFlags,
BYTE eventCode, UINT16* sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s,
size_t iEventCount, UINT16 sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_input_pdu(rdpFastPath* fastpath, wStream* s, UINT16 sec_flags);
WINPR_ATTR_MALLOC(Stream_Release, 1)
@@ -146,14 +161,22 @@ FREERDP_LOCAL wStream* fastpath_update_pdu_init(rdpFastPath* fastpath);
WINPR_ATTR_MALLOC(Stream_Free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* fastpath_update_pdu_init_new(rdpFastPath* fastpath);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s,
BOOL skipCompression);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_surfcmd_frame_marker(rdpFastPath* fastpath, UINT16 frameAction,
UINT32 frameId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BYTE fastpath_get_encryption_flags(rdpFastPath* fastpath);
FREERDP_LOCAL rdpFastPath* fastpath_new(rdpRdp* rdp);
FREERDP_LOCAL void fastpath_free(rdpFastPath* fastpath);
WINPR_ATTR_MALLOC(fastpath_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpFastPath* fastpath_new(rdpRdp* rdp);
#endif /* FREERDP_LIB_CORE_FASTPATH_H */

3
libfreerdp/core/freerdp.c
View File

@@ -293,7 +293,8 @@ BOOL freerdp_connect(freerdp* instance)
if (rdp->errorInfo == ERRINFO_SERVER_INSUFFICIENT_PRIVILEGES)
freerdp_set_last_error_log(instance->context, FREERDP_ERROR_INSUFFICIENT_PRIVILEGES);
transport_set_connected_event(rdp->transport);
if (status)
status = transport_set_connected_event(rdp->transport);
freerdp_connect_finally:
EventArgsInit(&e, "freerdp");

1
libfreerdp/core/gateway/arm.h
View File

@@ -26,6 +26,7 @@
#include <freerdp/api.h>
#include <freerdp/types.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL arm_resolve_endpoint(wLog* log, rdpContext* context, DWORD timeout);
#endif /* FREERDP_LIB_CORE_GATEWAY_ARM_H */

3
libfreerdp/core/gateway/http.c
View File

@@ -368,8 +368,7 @@ BOOL http_context_set_rdg_correlation_id(HttpContext* context, const GUID* RdgCo
BOOL http_context_enable_websocket_upgrade(HttpContext* context, BOOL enable)
{
if (!context)
return FALSE;
WINPR_ASSERT(context);
if (enable)
{

69
libfreerdp/core/gateway/http.h
View File

@@ -59,36 +59,70 @@ WINPR_ATTR_MALLOC(http_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HttpContext* http_context_new(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_method(HttpContext* context, const char* Method);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* http_context_get_uri(HttpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_uri(HttpContext* context, const char* URI);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_user_agent(HttpContext* context, const char* UserAgent);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_x_ms_user_agent(HttpContext* context, const char* UserAgent);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_host(HttpContext* context, const char* Host);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_accept(HttpContext* context, const char* Accept);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_cache_control(HttpContext* context, const char* CacheControl);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_connection(HttpContext* context, const char* Connection);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_pragma(HttpContext* context,
WINPR_FORMAT_ARG const char* Pragma, ...);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_append_pragma(HttpContext* context,
WINPR_FORMAT_ARG const char* Pragma, ...);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_cookie(HttpContext* context, const char* CookieName,
const char* CookieValue);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_rdg_connection_id(HttpContext* context,
const GUID* RdgConnectionId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_rdg_correlation_id(HttpContext* context,
const GUID* RdgConnectionId);
WINPR_ATTR_NODISCARD
WINPR_ATTR_FORMAT_ARG(3, 4)
FREERDP_LOCAL BOOL http_context_set_header(HttpContext* context, const char* key,
WINPR_FORMAT_ARG const char* value, ...);
WINPR_ATTR_NODISCARD
WINPR_ATTR_FORMAT_ARG(3, 0)
FREERDP_LOCAL BOOL http_context_set_header_va(HttpContext* context, const char* key,
WINPR_FORMAT_ARG const char* value, va_list ap);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_rdg_auth_scheme(HttpContext* context,
const char* RdgAuthScheme);
FREERDP_LOCAL BOOL http_context_enable_websocket_upgrade(HttpContext* context, BOOL enable);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_is_websocket_upgrade_enabled(HttpContext* context);
/* HTTP request */
@@ -100,21 +134,41 @@ WINPR_ATTR_MALLOC(http_request_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HttpRequest* http_request_new(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_method(HttpRequest* request, const char* Method);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_content_type(HttpRequest* request, const char* ContentType);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T http_request_get_content_length(HttpRequest* request);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_content_length(HttpRequest* request, size_t length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* http_request_get_uri(HttpRequest* request);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_uri(HttpRequest* request, const char* URI);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_auth_scheme(HttpRequest* request, const char* AuthScheme);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_auth_param(HttpRequest* request, const char* AuthParam);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_request_set_transfer_encoding(HttpRequest* request,
TRANSFER_ENCODING TransferEncoding);
WINPR_ATTR_NODISCARD
WINPR_ATTR_FORMAT_ARG(3, 4)
FREERDP_LOCAL BOOL http_request_set_header(HttpRequest* request, const char* key,
WINPR_FORMAT_ARG const char* value, ...);
WINPR_ATTR_MALLOC(Stream_Free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* http_request_write(HttpContext* context, HttpRequest* request);
/* HTTP response */
@@ -130,16 +184,30 @@ WINPR_ATTR_MALLOC(http_response_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HttpResponse* http_response_recv(rdpTls* tls, BOOL readContentLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT16 http_response_get_status_code(const HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t http_response_get_body_length(const HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* http_response_get_body(const HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* http_response_get_auth_token(const HttpResponse* response,
const char* method);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* http_response_get_setcookie(const HttpResponse* response,
const char* cookie);
FREERDP_LOCAL BOOL http_response_extract_cookies(const HttpResponse* response,
HttpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL TRANSFER_ENCODING http_response_get_transfer_encoding(const HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_response_is_websocket(const HttpContext* http,
const HttpResponse* response);
@@ -150,6 +218,7 @@ FREERDP_LOCAL void http_response_log_error_status_(wLog* log, DWORD level,
size_t line, const char* fkt);
/* chunked read helper */
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int http_chuncked_read(BIO* bio, BYTE* pBuffer, size_t size,
http_encoding_chunked_context* encodingContext);

10
libfreerdp/core/gateway/ncacn_http.h
View File

@@ -25,17 +25,27 @@
#include "rpc.h"
#include "http.h"
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_auth_init(rdpContext* context, RpcChannel* channel);
FREERDP_LOCAL void rpc_ncacn_http_auth_uninit(RpcChannel* channel);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_send_in_channel_request(RpcChannel* inChannel);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_recv_in_channel_response(RpcChannel* inChannel,
HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_send_out_channel_request(RpcChannel* outChannel,
BOOL replacement);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_recv_out_channel_response(RpcChannel* outChannel,
HttpResponse* response);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_ncacn_http_is_final_request(RpcChannel* channel);
#endif /* FREERDP_LIB_CORE_GATEWAY_NCACN_HTTP_H */

9
libfreerdp/core/gateway/rdg.c
View File

@@ -720,11 +720,14 @@ static wStream* rdg_build_http_request(rdpRdg* rdg, const char* method,
else if (rdg->extAuth == HTTP_EXTENDED_AUTH_BEARER)
{
http_request_set_auth_scheme(request, "Bearer");
http_request_set_auth_param(request, rdg->context->settings->GatewayHttpExtAuthBearer);
if (!http_request_set_auth_scheme(request, "Bearer"))
goto out;
if (!http_request_set_auth_param(request, rdg->context->settings->GatewayHttpExtAuthBearer))
goto out;
}
http_request_set_transfer_encoding(request, transferEncoding);
if (!http_request_set_transfer_encoding(request, transferEncoding))
goto out;
s = http_request_write(rdg->http, request);
out:

7
libfreerdp/core/gateway/rdg.h
View File

@@ -24,6 +24,9 @@
#include <winpr/stream.h>
#include <winpr/winpr.h>
#include <freerdp/api.h>
#include <freerdp/types.h>
/* needed for BIO */
#include <openssl/ssl.h>
@@ -35,9 +38,13 @@ WINPR_ATTR_MALLOC(rdg_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpRdg* rdg_new(rdpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO* rdg_get_front_bio_and_take_ownership(rdpRdg* rdg);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdg_connect(rdpRdg* rdg, DWORD timeout, BOOL* rpcFallback);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD rdg_get_event_handles(rdpRdg* rdg, HANDLE* events, DWORD count);
#endif /* FREERDP_LIB_CORE_GATEWAY_RDG_H */

11
libfreerdp/core/gateway/rpc.c
View File

@@ -500,9 +500,7 @@ SSIZE_T rpc_channel_write_int(RpcChannel* channel, const BYTE* data, size_t leng
BOOL rpc_in_channel_transition_to_state(RpcInChannel* inChannel, CLIENT_IN_CHANNEL_STATE state)
{
if (!inChannel)
return FALSE;
WINPR_ASSERT(inChannel);
inChannel->State = state;
WLog_Print(inChannel->common.rpc->log, WLOG_DEBUG, "%s", client_in_state_str(state));
return TRUE;
@@ -617,8 +615,7 @@ void rpc_channel_free(RpcChannel* channel)
BOOL rpc_out_channel_transition_to_state(RpcOutChannel* outChannel, CLIENT_OUT_CHANNEL_STATE state)
{
if (!outChannel)
return FALSE;
WINPR_ASSERT(outChannel);
outChannel->State = state;
WLog_Print(outChannel->common.rpc->log, WLOG_DEBUG, "%s", client_out_state_str(state));
@@ -659,9 +656,7 @@ RpcOutChannel* rpc_out_channel_new(rdpRpc* rpc, const GUID* guid)
BOOL rpc_virtual_connection_transition_to_state(rdpRpc* rpc, RpcVirtualConnection* connection,
VIRTUAL_CONNECTION_STATE state)
{
if (!connection)
return FALSE;
WINPR_ASSERT(connection);
WINPR_ASSERT(rpc);
connection->State = state;
WLog_Print(rpc->log, WLOG_DEBUG, "%s", rpc_vc_state_str(state));

12
libfreerdp/core/gateway/rpc.h
View File

@@ -763,21 +763,29 @@ struct rdp_rpc
wLog* log;
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rpc_vc_state_str(VIRTUAL_CONNECTION_STATE state);
FREERDP_LOCAL void rpc_pdu_header_print(wLog* log, const rpcconn_hdr_t* header);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rpcconn_common_hdr_t rpc_pdu_header_init(const rdpRpc* rpc);
FREERDP_LOCAL size_t rpc_offset_align(size_t* offset, size_t alignment);
FREERDP_LOCAL size_t rpc_offset_pad(size_t* offset, size_t pad);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_get_stub_data_info(rdpRpc* rpc, const rpcconn_hdr_t* header, size_t* offset,
size_t* length);
#define rpc_channel_write(channel, data, length) \
rpc_channel_write_int((channel), (data), (length), __FILE__, __LINE__, __func__)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T rpc_channel_write_int(RpcChannel* channel, const BYTE* data, size_t length,
const char* file, size_t line, const char* fkt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T rpc_channel_read(RpcChannel* channel, wStream* s, size_t length);
FREERDP_LOCAL void rpc_channel_free(RpcChannel* channel);
@@ -785,10 +793,13 @@ FREERDP_LOCAL void rpc_channel_free(RpcChannel* channel);
WINPR_ATTR_MALLOC(rpc_channel_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL RpcOutChannel* rpc_out_channel_new(rdpRpc* rpc, const GUID* guid);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_out_channel_replacement_connect(RpcOutChannel* outChannel, uint32_t timeout);
FREERDP_LOCAL BOOL rpc_in_channel_transition_to_state(RpcInChannel* inChannel,
CLIENT_IN_CHANNEL_STATE state);
FREERDP_LOCAL BOOL rpc_out_channel_transition_to_state(RpcOutChannel* outChannel,
CLIENT_OUT_CHANNEL_STATE state);
@@ -796,6 +807,7 @@ FREERDP_LOCAL BOOL rpc_virtual_connection_transition_to_state(rdpRpc* rpc,
RpcVirtualConnection* connection,
VIRTUAL_CONNECTION_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_connect(rdpRpc* rpc, UINT32 timeout);
FREERDP_LOCAL void rpc_free(rdpRpc* rpc);

9
libfreerdp/core/gateway/rpc_bind.h
View File

@@ -41,10 +41,19 @@ enum RPC_BIND_STATE
RPC_BIND_STATE_COMPLETE
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_send_bind_pdu(rdpRpc* rpc, BOOL initial);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_recv_bind_ack_pdu(rdpRpc* rpc, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_send_rpc_auth_3_pdu(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL enum RPC_BIND_STATE rpc_bind_state(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BYTE rpc_auth_pkg_to_security_provider(const char* name);
#endif /* FREERDP_LIB_CORE_GATEWAY_RPC_BIND_H */

3
libfreerdp/core/gateway/rpc_client.c
View File

@@ -691,7 +691,8 @@ static SSIZE_T rpc_client_default_out_channel_recv(rdpRpc* rpc)
Stream_SetPosition(fragment, 0);
/* Ignore errors, the PDU might not be complete. */
rts_read_common_pdu_header(fragment, &header, TRUE);
if (!rts_read_common_pdu_header(fragment, &header, TRUE))
return -1;
Stream_SetPosition(fragment, pos);
if (header.frag_length > rpc->max_recv_frag)

7
libfreerdp/core/gateway/rpc_client.h
View File

@@ -26,6 +26,7 @@
#include "rpc.h"
WINPR_ATTR_NODISCARD
FREERDP_LOCAL RpcClientCall* rpc_client_call_find_by_id(RpcClient* client, UINT32 CallId);
FREERDP_LOCAL void rpc_client_call_free(RpcClientCall* client_call);
@@ -34,14 +35,20 @@ WINPR_ATTR_MALLOC(rpc_client_call_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL RpcClientCall* rpc_client_call_new(UINT32 CallId, UINT32 OpNum);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_in_channel_send_pdu(RpcInChannel* inChannel, const BYTE* buffer,
size_t length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_client_in_channel_recv(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_client_out_channel_recv(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rpc_client_receive_pipe_read(RpcClient* client, BYTE* buffer, size_t length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rpc_client_write_call(rdpRpc* rpc, wStream* s, UINT16 opnum);
FREERDP_LOCAL void rpc_client_free(RpcClient* client);

4
libfreerdp/core/gateway/rpc_fault.h
View File

@@ -24,7 +24,11 @@
#include <freerdp/api.h>
FREERDP_LOCAL int rpc_recv_fault_pdu(UINT32 status);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rpc_error_to_string(UINT32 error);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rpc_error_to_category(UINT32 error);
#endif /* FREERDP_LIB_CORE_GATEWAY_RPC_FAULT_H */

20
libfreerdp/core/gateway/rts.h
View File

@@ -79,37 +79,56 @@
FREERDP_LOCAL void rts_generate_cookie(BYTE* cookie);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_write_pdu_auth3(wStream* s, const rpcconn_rpc_auth_3_hdr_t* auth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_write_pdu_bind(wStream* s, const rpcconn_bind_hdr_t* bind);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_read_pdu_header(wStream* s, rpcconn_hdr_t* header);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_read_pdu_header_ex(wStream* s, rpcconn_hdr_t* header, BOOL silent);
FREERDP_LOCAL void rts_free_pdu_header(rpcconn_hdr_t* header, BOOL allocated);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_read_common_pdu_header(wStream* s, rpcconn_common_hdr_t* header,
BOOL ignoreErrors);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_command_length(UINT32 CommandType, wStream* s, size_t* length, BOOL silent);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_send_CONN_A1_pdu(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_recv_CONN_A3_pdu(rdpRpc* rpc, wStream* buffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_send_CONN_B1_pdu(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_recv_CONN_C2_pdu(rdpRpc* rpc, wStream* buffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_send_OUT_R1_A3_pdu(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_send_flow_control_ack_pdu(rdpRpc* rpc);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_recv_out_of_sequence_pdu(rdpRpc* rpc, wStream* buffer,
const rpcconn_hdr_t* header);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_recv_ping_pdu(rdpRpc* rpc, wStream* s);
#define Stream_ConditionalCheckAndLogRequiredLength(tag, s, size, silent) \
rts_conditional_check_and_log(tag, s, size, silent, __func__, __FILE__, __LINE__)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_conditional_check_and_log(const char* tag, wStream* s, size_t size,
BOOL silent, const char* fkt, const char* file,
size_t line);
@@ -117,6 +136,7 @@ FREERDP_LOCAL BOOL rts_conditional_check_and_log(const char* tag, wStream* s, si
#define Stream_ConditionalSafeSeek(s, size, silent) \
rts_conditional_safe_seek(s, size, silent, __func__, __FILE__, __LINE__)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_conditional_safe_seek(wStream* s, size_t size, BOOL silent, const char* fkt,
const char* file, size_t line);

3
libfreerdp/core/gateway/rts_signature.c
View File

@@ -402,8 +402,7 @@ BOOL rts_print_pdu_signature(wLog* log, DWORD level, const RtsPduSignature* sign
UINT32 SignatureId = 0;
const RTS_PDU_SIGNATURE_ENTRY* entry = NULL;
if (!signature)
return FALSE;
WINPR_ASSERT(signature);
WLog_Print(log, level,
"RTS PDU Signature: Flags: 0x%04" PRIX16 " NumberOfCommands: %" PRIu16 "",

10
libfreerdp/core/gateway/rts_signature.h
View File

@@ -175,17 +175,27 @@ FREERDP_LOCAL extern const RtsPduSignature RTS_PDU_PING_SIGNATURE;
FREERDP_LOCAL extern const RtsPduSignature RTS_PDU_FLOW_CONTROL_ACK_SIGNATURE;
FREERDP_LOCAL extern const RtsPduSignature RTS_PDU_FLOW_CONTROL_ACK_WITH_DESTINATION_SIGNATURE;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_match_pdu_signature(const RtsPduSignature* signature, wStream* s,
const rpcconn_hdr_t* header);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_match_pdu_signature_ex(const RtsPduSignature* signature, wStream* s,
const rpcconn_hdr_t* header,
RtsPduSignature* found_signature, BOOL silent);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_extract_pdu_signature(RtsPduSignature* signature, wStream* s,
const rpcconn_hdr_t* header);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rts_extract_pdu_signature_ex(RtsPduSignature* signature, wStream* s,
const rpcconn_hdr_t* header, BOOL silent);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT32 rts_identify_pdu_signature(const RtsPduSignature* signature,
const RTS_PDU_SIGNATURE_ENTRY** entry);
FREERDP_LOCAL BOOL rts_print_pdu_signature(wLog* log, DWORD level,
const RtsPduSignature* signature);

4
libfreerdp/core/gateway/tsg.c
View File

@@ -3338,9 +3338,7 @@ BIO* tsg_get_bio(rdpTsg* tsg)
BOOL tsg_set_state(rdpTsg* tsg, TSG_STATE state)
{
if (!tsg)
return FALSE;
WINPR_ASSERT(tsg);
tsg->state = state;
return TRUE;
}

11
libfreerdp/core/gateway/tsg.h
View File

@@ -103,19 +103,30 @@ WINPR_ATTR_MALLOC(tsg_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpTsg* tsg_new(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tsg_proxy_begin(rdpTsg* tsg);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tsg_connect(rdpTsg* tsg, const char* hostname, UINT16 port, DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tsg_disconnect(rdpTsg* tsg);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tsg_recv_pdu(rdpTsg* tsg, const RPC_PDU* pdu);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tsg_check_event_handles(rdpTsg* tsg);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD tsg_get_event_handles(rdpTsg* tsg, HANDLE* events, DWORD count);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL TSG_STATE tsg_get_state(rdpTsg* tsg);
FREERDP_LOCAL BOOL tsg_set_state(rdpTsg* tsg, TSG_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO* tsg_get_bio(rdpTsg* tsg);
#endif /* FREERDP_LIB_CORE_GATEWAY_TSG_H */

7
libfreerdp/core/gateway/websocket.h
View File

@@ -58,12 +58,18 @@ WINPR_ATTR_MALLOC(websocket_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL websocket_context* websocket_context_new(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL websocket_context_reset(websocket_context* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL websocket_context_write_wstream(websocket_context* context, BIO* bio,
wStream* sPacket, WEBSOCKET_OPCODE opcode);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int websocket_context_write(websocket_context* context, BIO* bio, const BYTE* buf,
int isize, WEBSOCKET_OPCODE opcode);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int websocket_context_read(websocket_context* encodingContext, BIO* bio,
BYTE* pBuffer, size_t size);
@@ -72,6 +78,7 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* websocket_context_packet_new(size_t len, WEBSOCKET_OPCODE opcode,
UINT32* pMaskingKey);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL websocket_context_mask_and_send(BIO* bio, wStream* sPacket, wStream* sDataPacket,
UINT32 maskingKey);

26
libfreerdp/core/gateway/wst.c
View File

@@ -315,10 +315,12 @@ static wStream* wst_build_http_request(rdpWst* wst)
}
else if (freerdp_settings_get_string(wst->context->settings, FreeRDP_GatewayHttpExtAuthBearer))
{
http_request_set_auth_scheme(request, "Bearer");
http_request_set_auth_param(
request,
freerdp_settings_get_string(wst->context->settings, FreeRDP_GatewayHttpExtAuthBearer));
if (!http_request_set_auth_scheme(request, "Bearer"))
goto out;
if (!http_request_set_auth_param(
request, freerdp_settings_get_string(wst->context->settings,
FreeRDP_GatewayHttpExtAuthBearer)))
goto out;
}
s = http_request_write(wst->http, request);
@@ -365,9 +367,15 @@ static BOOL wst_handle_ok_or_forbidden(rdpWst* wst, HttpResponse** ppresponse, D
WLog_Print(wst->log, WLOG_INFO, "Got ARRAffinity cookie %s", affinity);
WLog_Print(wst->log, WLOG_INFO, "Got ARRAffinitySameSite cookie %s", samesite);
if (affinity)
http_context_set_cookie(wst->http, "ARRAffinity", affinity);
{
if (!http_context_set_cookie(wst->http, "ARRAffinity", affinity))
return FALSE;
}
if (samesite)
http_context_set_cookie(wst->http, "ARRAffinitySameSite", samesite);
{
if (!http_context_set_cookie(wst->http, "ARRAffinitySameSite", samesite))
return FALSE;
}
http_response_free(*ppresponse);
*ppresponse = NULL;
/* Terminate this connection and make a new one with the Loadbalancing Cookie */
@@ -523,7 +531,11 @@ BOOL wst_connect(rdpWst* wst, DWORD timeout)
* we need to get a Loadbalancing Cookie (ARRAffinity)
* This is done by a plain GET request on the websocket URL
*/
http_context_enable_websocket_upgrade(wst->http, FALSE);
if (!http_context_enable_websocket_upgrade(wst->http, FALSE))
{
freerdp_set_last_error_if_not(wst->context, FREERDP_ERROR_CONNECT_FAILED);
return FALSE;
}
}
if (!wst_send_http_request(wst, wst->tls))
{

7
libfreerdp/core/gateway/wst.h
View File

@@ -24,6 +24,9 @@
#include <winpr/stream.h>
#include <winpr/winpr.h>
#include <freerdp/api.h>
#include <freerdp/types.h>
/* needed for BIO */
#include <openssl/ssl.h>
@@ -35,9 +38,13 @@ WINPR_ATTR_MALLOC(wst_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpWst* wst_new(rdpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO* wst_get_front_bio_and_take_ownership(rdpWst* wst);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL wst_connect(rdpWst* wst, DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD wst_get_event_handles(rdpWst* wst, HANDLE* events, DWORD count);
#endif /* FREERDP_LIB_CORE_GATEWAY_WEBSOCKET_TRANSPORT_H */

11
libfreerdp/core/gcc.h
View File

@@ -30,11 +30,22 @@
#include <winpr/stream.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_write_conference_create_request(wStream* s, wStream* userData);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_write_conference_create_response(wStream* s, wStream* userData);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_write_client_data_blocks(wStream* s, const rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gcc_write_server_data_blocks(wStream* s, rdpMcs* mcs);
#endif /* FREERDP_LIB_CORE_GCC_H */

1
libfreerdp/core/heartbeat.h
View File

@@ -31,6 +31,7 @@
#include "state.h"
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_heartbeat_packet(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL void heartbeat_free(rdpHeartbeat* heartbeat);

9
libfreerdp/core/info.h
View File

@@ -58,10 +58,19 @@
#define SAVE_SESSION_PDU_VERSION_ONE 0x0001
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_client_info(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_client_info(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_recv_save_session_info(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_save_session_info(rdpContext* context, UINT32 type, void* data);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_server_status_info(rdpContext* context, UINT32 status);
#endif /* FREERDP_LIB_CORE_INFO_H */

5
libfreerdp/core/input.h
View File

@@ -44,6 +44,7 @@ typedef struct
wLog* log;
} rdp_input_internal;
WINPR_ATTR_NODISCARD
static inline rdp_input_internal* input_cast(rdpInput* input)
{
union
@@ -57,9 +58,13 @@ static inline rdp_input_internal* input_cast(rdpInput* input)
return cnv.internal;
}
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL input_recv(rdpInput* input, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int input_process_events(rdpInput* input);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL input_register_client_callbacks(rdpInput* input);
FREERDP_LOCAL void input_free(rdpInput* input);

5
libfreerdp/core/license.h
View File

@@ -56,12 +56,17 @@ typedef struct
LICENSE_BLOB** array;
} SCOPE_LIST;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL license_send_valid_client_error_packet(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t license_recv(rdpLicense* license, wStream* s);
/* the configuration is applied from settings. Set FreeRDP_ServerLicense* settings */
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL license_server_configure(rdpLicense* license);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL license_server_send_request(rdpLicense* license);
FREERDP_LOCAL void license_free(rdpLicense* license);

12
libfreerdp/core/mcs.c
View File

@@ -1079,7 +1079,8 @@ BOOL mcs_send_erect_domain_request(rdpMcs* mcs)
return FALSE;
}
mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ErectDomainRequest, length, 0);
if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ErectDomainRequest, length, 0))
goto out;
if (!per_write_integer(s, 0)) /* subHeight (INTEGER) */
goto out;
if (!per_write_integer(s, 0)) /* subInterval (INTEGER) */
@@ -1120,6 +1121,7 @@ BOOL mcs_recv_attach_user_request(rdpMcs* mcs, wStream* s)
BOOL mcs_send_attach_user_request(rdpMcs* mcs)
{
int status = -1;
UINT16 length = 8;
if (!mcs)
@@ -1133,11 +1135,15 @@ BOOL mcs_send_attach_user_request(rdpMcs* mcs)
return FALSE;
}
mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, length, 0);
if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, length, 0))
goto fail;
Stream_SealLength(s);
rdpTransport* transport = freerdp_get_transport(mcs->context);
const int status = transport_write(transport, s);
status = transport_write(transport, s);
fail:
Stream_Free(s, TRUE);
return (status < 0) ? FALSE : TRUE;
}

37
libfreerdp/core/mcs.h
View File

@@ -156,30 +156,63 @@ struct rdp_mcs
#define MCS_TYPE_CONNECT_INITIAL 0x65
#define MCS_TYPE_CONNECT_RESPONSE 0x66
const char* mcs_domain_pdu_string(DomainMCSPDU pdu);
BOOL mcs_server_apply_to_settings(const rdpMcs* mcs, rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* mcs_domain_pdu_string(DomainMCSPDU pdu);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_server_apply_to_settings(const rdpMcs* mcs, rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_connect_response(rdpMcs* mcs, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_connect_response(rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_erect_domain_request(rdpMcs* mcs, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_erect_domain_request(rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_attach_user_request(rdpMcs* mcs, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_attach_user_request(rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_attach_user_confirm(rdpMcs* mcs, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_attach_user_confirm(rdpMcs* mcs);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_channel_join_request(rdpMcs* mcs, const rdpSettings* settings,
wStream* s, UINT16* channelId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channelId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channelId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channelId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_recv_disconnect_provider_ultimatum(rdpMcs* mcs, wStream* s, int* reason);
FREERDP_LOCAL BOOL mcs_send_disconnect_provider_ultimatum(rdpMcs* mcs,
enum Disconnect_Ultimatum reason);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_write_domain_mcspdu_header(wStream* s, DomainMCSPDU domainMCSPDU,
UINT16 length, BYTE options);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL mcs_client_begin(rdpMcs* mcs);
FREERDP_LOCAL void mcs_free(rdpMcs* mcs);

149
libfreerdp/core/message.h
View File

@@ -36,101 +36,104 @@ struct rdp_update_proxy
/* Update */
pBeginPaint BeginPaint;
pEndPaint EndPaint;
pSetBounds SetBounds;
pSynchronize Synchronize;
pDesktopResize DesktopResize;
pBitmapUpdate BitmapUpdate;
pPalette Palette;
pPlaySound PlaySound;
pSetKeyboardIndicators SetKeyboardIndicators;
pSetKeyboardImeStatus SetKeyboardImeStatus;
pRefreshRect RefreshRect;
pSuppressOutput SuppressOutput;
pSurfaceCommand SurfaceCommand;
pSurfaceBits SurfaceBits;
pSurfaceFrameMarker SurfaceFrameMarker;
pSurfaceFrameAcknowledge SurfaceFrameAcknowledge;
WINPR_ATTR_NODISCARD pBeginPaint BeginPaint;
WINPR_ATTR_NODISCARD pEndPaint EndPaint;
WINPR_ATTR_NODISCARD pSetBounds SetBounds;
WINPR_ATTR_NODISCARD pSynchronize Synchronize;
WINPR_ATTR_NODISCARD pDesktopResize DesktopResize;
WINPR_ATTR_NODISCARD pBitmapUpdate BitmapUpdate;
WINPR_ATTR_NODISCARD pPalette Palette;
WINPR_ATTR_NODISCARD pPlaySound PlaySound;
WINPR_ATTR_NODISCARD pSetKeyboardIndicators SetKeyboardIndicators;
WINPR_ATTR_NODISCARD pSetKeyboardImeStatus SetKeyboardImeStatus;
WINPR_ATTR_NODISCARD pRefreshRect RefreshRect;
WINPR_ATTR_NODISCARD pSuppressOutput SuppressOutput;
WINPR_ATTR_NODISCARD pSurfaceCommand SurfaceCommand;
WINPR_ATTR_NODISCARD pSurfaceBits SurfaceBits;
WINPR_ATTR_NODISCARD pSurfaceFrameMarker SurfaceFrameMarker;
WINPR_ATTR_NODISCARD pSurfaceFrameAcknowledge SurfaceFrameAcknowledge;
/* Primary Update */
pDstBlt DstBlt;
pPatBlt PatBlt;
pScrBlt ScrBlt;
pOpaqueRect OpaqueRect;
pDrawNineGrid DrawNineGrid;
pMultiDstBlt MultiDstBlt;
pMultiPatBlt MultiPatBlt;
pMultiScrBlt MultiScrBlt;
pMultiOpaqueRect MultiOpaqueRect;
pMultiDrawNineGrid MultiDrawNineGrid;
pLineTo LineTo;
pPolyline Polyline;
pMemBlt MemBlt;
pMem3Blt Mem3Blt;
pSaveBitmap SaveBitmap;
pGlyphIndex GlyphIndex;
pFastIndex FastIndex;
pFastGlyph FastGlyph;
pPolygonSC PolygonSC;
pPolygonCB PolygonCB;
pEllipseSC EllipseSC;
pEllipseCB EllipseCB;
WINPR_ATTR_NODISCARD pDstBlt DstBlt;
WINPR_ATTR_NODISCARD pPatBlt PatBlt;
WINPR_ATTR_NODISCARD pScrBlt ScrBlt;
WINPR_ATTR_NODISCARD pOpaqueRect OpaqueRect;
WINPR_ATTR_NODISCARD pDrawNineGrid DrawNineGrid;
WINPR_ATTR_NODISCARD pMultiDstBlt MultiDstBlt;
WINPR_ATTR_NODISCARD pMultiPatBlt MultiPatBlt;
WINPR_ATTR_NODISCARD pMultiScrBlt MultiScrBlt;
WINPR_ATTR_NODISCARD pMultiOpaqueRect MultiOpaqueRect;
WINPR_ATTR_NODISCARD pMultiDrawNineGrid MultiDrawNineGrid;
WINPR_ATTR_NODISCARD pLineTo LineTo;
WINPR_ATTR_NODISCARD pPolyline Polyline;
WINPR_ATTR_NODISCARD pMemBlt MemBlt;
WINPR_ATTR_NODISCARD pMem3Blt Mem3Blt;
WINPR_ATTR_NODISCARD pSaveBitmap SaveBitmap;
WINPR_ATTR_NODISCARD pGlyphIndex GlyphIndex;
WINPR_ATTR_NODISCARD pFastIndex FastIndex;
WINPR_ATTR_NODISCARD pFastGlyph FastGlyph;
WINPR_ATTR_NODISCARD pPolygonSC PolygonSC;
WINPR_ATTR_NODISCARD pPolygonCB PolygonCB;
WINPR_ATTR_NODISCARD pEllipseSC EllipseSC;
WINPR_ATTR_NODISCARD pEllipseCB EllipseCB;
/* Secondary Update */
pCacheBitmap CacheBitmap;
pCacheBitmapV2 CacheBitmapV2;
pCacheBitmapV3 CacheBitmapV3;
pCacheColorTable CacheColorTable;
pCacheGlyph CacheGlyph;
pCacheGlyphV2 CacheGlyphV2;
pCacheBrush CacheBrush;
WINPR_ATTR_NODISCARD pCacheBitmap CacheBitmap;
WINPR_ATTR_NODISCARD pCacheBitmapV2 CacheBitmapV2;
WINPR_ATTR_NODISCARD pCacheBitmapV3 CacheBitmapV3;
WINPR_ATTR_NODISCARD pCacheColorTable CacheColorTable;
WINPR_ATTR_NODISCARD pCacheGlyph CacheGlyph;
WINPR_ATTR_NODISCARD pCacheGlyphV2 CacheGlyphV2;
WINPR_ATTR_NODISCARD pCacheBrush CacheBrush;
/* Alternate Secondary Update */
pCreateOffscreenBitmap CreateOffscreenBitmap;
pSwitchSurface SwitchSurface;
pCreateNineGridBitmap CreateNineGridBitmap;
pFrameMarker FrameMarker;
pStreamBitmapFirst StreamBitmapFirst;
pStreamBitmapNext StreamBitmapNext;
pDrawGdiPlusFirst DrawGdiPlusFirst;
pDrawGdiPlusNext DrawGdiPlusNext;
pDrawGdiPlusEnd DrawGdiPlusEnd;
pDrawGdiPlusCacheFirst DrawGdiPlusCacheFirst;
pDrawGdiPlusCacheNext DrawGdiPlusCacheNext;
pDrawGdiPlusCacheEnd DrawGdiPlusCacheEnd;
WINPR_ATTR_NODISCARD pCreateOffscreenBitmap CreateOffscreenBitmap;
WINPR_ATTR_NODISCARD pSwitchSurface SwitchSurface;
WINPR_ATTR_NODISCARD pCreateNineGridBitmap CreateNineGridBitmap;
WINPR_ATTR_NODISCARD pFrameMarker FrameMarker;
WINPR_ATTR_NODISCARD pStreamBitmapFirst StreamBitmapFirst;
WINPR_ATTR_NODISCARD pStreamBitmapNext StreamBitmapNext;
WINPR_ATTR_NODISCARD pDrawGdiPlusFirst DrawGdiPlusFirst;
WINPR_ATTR_NODISCARD pDrawGdiPlusNext DrawGdiPlusNext;
WINPR_ATTR_NODISCARD pDrawGdiPlusEnd DrawGdiPlusEnd;
WINPR_ATTR_NODISCARD pDrawGdiPlusCacheFirst DrawGdiPlusCacheFirst;
WINPR_ATTR_NODISCARD pDrawGdiPlusCacheNext DrawGdiPlusCacheNext;
WINPR_ATTR_NODISCARD pDrawGdiPlusCacheEnd DrawGdiPlusCacheEnd;
/* Window Update */
pWindowCreate WindowCreate;
pWindowUpdate WindowUpdate;
pWindowIcon WindowIcon;
pWindowCachedIcon WindowCachedIcon;
pWindowDelete WindowDelete;
pNotifyIconCreate NotifyIconCreate;
pNotifyIconUpdate NotifyIconUpdate;
pNotifyIconDelete NotifyIconDelete;
pMonitoredDesktop MonitoredDesktop;
pNonMonitoredDesktop NonMonitoredDesktop;
WINPR_ATTR_NODISCARD pWindowCreate WindowCreate;
WINPR_ATTR_NODISCARD pWindowUpdate WindowUpdate;
WINPR_ATTR_NODISCARD pWindowIcon WindowIcon;
WINPR_ATTR_NODISCARD pWindowCachedIcon WindowCachedIcon;
WINPR_ATTR_NODISCARD pWindowDelete WindowDelete;
WINPR_ATTR_NODISCARD pNotifyIconCreate NotifyIconCreate;
WINPR_ATTR_NODISCARD pNotifyIconUpdate NotifyIconUpdate;
WINPR_ATTR_NODISCARD pNotifyIconDelete NotifyIconDelete;
WINPR_ATTR_NODISCARD pMonitoredDesktop MonitoredDesktop;
WINPR_ATTR_NODISCARD pNonMonitoredDesktop NonMonitoredDesktop;
/* Pointer Update */
pPointerPosition PointerPosition;
pPointerSystem PointerSystem;
pPointerColor PointerColor;
pPointerNew PointerNew;
pPointerCached PointerCached;
pPointerLarge PointerLarge;
WINPR_ATTR_NODISCARD pPointerPosition PointerPosition;
WINPR_ATTR_NODISCARD pPointerSystem PointerSystem;
WINPR_ATTR_NODISCARD pPointerColor PointerColor;
WINPR_ATTR_NODISCARD pPointerNew PointerNew;
WINPR_ATTR_NODISCARD pPointerCached PointerCached;
WINPR_ATTR_NODISCARD pPointerLarge PointerLarge;
HANDLE thread;
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int update_message_queue_process_message(rdpUpdate* update, wMessage* message);
FREERDP_LOCAL int update_message_queue_free_message(wMessage* message);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int update_message_queue_process_pending_messages(rdpUpdate* update);
FREERDP_LOCAL void update_message_proxy_free(rdpUpdateProxy* message);

6
libfreerdp/core/multitransport.h
View File

@@ -44,10 +44,16 @@ typedef state_run_t (*MultiTransportResponseCb)(rdpMultitransport* multi, UINT32
#define RDPUDP_COOKIE_LEN 16
#define RDPUDP_COOKIE_HASHLEN 32
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t multitransport_recv_request(rdpMultitransport* multi, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t multitransport_server_request(rdpMultitransport* multi, UINT16 reqProto);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t multitransport_recv_response(rdpMultitransport* multi, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL multitransport_client_send_response(rdpMultitransport* multi, UINT32 reqId,
HRESULT hr);

12
libfreerdp/core/nego.c
View File

@@ -1554,9 +1554,11 @@ BOOL nego_send_negotiation_response(rdpNego* nego)
em = Stream_GetPosition(s);
Stream_SetPosition(s, bm);
status = tpkt_write_header(s, length);
if (status)
status = tpdu_write_connection_confirm(s, length - 5);
if (status)
{
tpdu_write_connection_confirm(s, length - 5);
Stream_SetPosition(s, em);
Stream_SealLength(s);
@@ -1739,8 +1741,8 @@ void nego_free(rdpNego* nego)
BOOL nego_set_target(rdpNego* nego, const char* hostname, UINT16 port)
{
if (!nego || !hostname)
return FALSE;
WINPR_ASSERT(nego);
WINPR_ASSERT(hostname);
nego->hostname = hostname;
nego->port = port;
@@ -2046,9 +2048,7 @@ NEGO_STATE nego_get_state(const rdpNego* nego)
BOOL nego_set_state(rdpNego* nego, NEGO_STATE state)
{
if (!nego)
return FALSE;
WINPR_ASSERT(nego);
nego->state = state;
return TRUE;
}

32
libfreerdp/core/nego.h
View File

@@ -97,13 +97,22 @@ typedef enum
typedef struct rdp_nego rdpNego;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_connect(rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_disconnect(rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int nego_recv(rdpTransport* transport, wStream* s, void* extra);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_read_request(rdpNego* nego, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_send_negotiation_request(rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_send_negotiation_response(rdpNego* nego);
FREERDP_LOCAL void nego_free(rdpNego* nego);
@@ -113,14 +122,19 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpNego* nego_new(rdpTransport* transport);
FREERDP_LOCAL void nego_init(rdpNego* nego);
FREERDP_LOCAL BOOL nego_set_target(rdpNego* nego, const char* hostname, UINT16 port);
FREERDP_LOCAL void nego_set_negotiation_enabled(rdpNego* nego, BOOL NegotiateSecurityLayer);
FREERDP_LOCAL void nego_set_restricted_admin_mode_required(rdpNego* nego,
BOOL RestrictedAdminModeRequired);
FREERDP_LOCAL void nego_set_restricted_admin_mode_supported(rdpNego* nego, BOOL enabled);
FREERDP_LOCAL void nego_set_RCG_required(rdpNego* nego, BOOL enabled);
FREERDP_LOCAL void nego_set_RCG_supported(rdpNego* nego, BOOL enabled);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_get_remoteCredentialGuard(const rdpNego* nego);
FREERDP_LOCAL void nego_set_childsession_enabled(rdpNego* nego, BOOL ChildSessionEnabled);
FREERDP_LOCAL void nego_set_gateway_enabled(rdpNego* nego, BOOL GatewayEnabled);
FREERDP_LOCAL void nego_set_gateway_bypass_local(rdpNego* nego, BOOL GatewayBypassLocal);
@@ -130,30 +144,48 @@ FREERDP_LOCAL void nego_enable_nla(rdpNego* nego, BOOL enable_nla);
FREERDP_LOCAL void nego_enable_rdstls(rdpNego* nego, BOOL enable_rdstls);
FREERDP_LOCAL void nego_enable_aad(rdpNego* nego, BOOL enable_aad);
FREERDP_LOCAL void nego_enable_ext(rdpNego* nego, BOOL enable_ext);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const BYTE* nego_get_routing_token(const rdpNego* nego, DWORD* RoutingTokenLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_set_routing_token(rdpNego* nego, const void* RoutingToken,
DWORD RoutingTokenLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_set_cookie(rdpNego* nego, const char* cookie);
FREERDP_LOCAL void nego_set_cookie_max_length(rdpNego* nego, UINT32 CookieMaxLength);
FREERDP_LOCAL void nego_set_send_preconnection_pdu(rdpNego* nego, BOOL SendPreconnectionPdu);
FREERDP_LOCAL void nego_set_preconnection_id(rdpNego* nego, UINT32 PreconnectionId);
FREERDP_LOCAL void nego_set_preconnection_blob(rdpNego* nego, const char* PreconnectionBlob);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT32 nego_get_selected_protocol(const rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_set_selected_protocol(rdpNego* nego, UINT32 SelectedProtocol);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT32 nego_get_requested_protocols(const rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_set_requested_protocols(rdpNego* nego, UINT32 RequestedProtocols);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nego_update_settings_from_state(rdpNego* nego, rdpSettings* settings);
FREERDP_LOCAL BOOL nego_set_state(rdpNego* nego, NEGO_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL NEGO_STATE nego_get_state(const rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SEC_WINNT_AUTH_IDENTITY* nego_get_identity(rdpNego* nego);
FREERDP_LOCAL void nego_free_nla(rdpNego* nego);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* nego_protocol_to_str(UINT32 protocol, char* buffer, size_t size);
#endif /* FREERDP_LIB_CORE_NEGO_H */

27
libfreerdp/core/nla.h
View File

@@ -46,27 +46,46 @@ typedef enum
NLA_STATE_FINAL
} NLA_STATE;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int nla_authenticate(rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int nla_client_begin(rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int nla_recv_pdu(rdpNla* nla, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SEC_WINNT_AUTH_IDENTITY* nla_get_identity(rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL NLA_STATE nla_get_state(const rdpNla* nla);
FREERDP_LOCAL BOOL nla_set_state(rdpNla* nla, NLA_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* nla_get_state_str(NLA_STATE state);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD nla_get_error(const rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL INT32 nla_get_sspi_error(const rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_set_service_principal(rdpNla* nla, const char* service,
const char* hostname);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_set_sspi_module(rdpNla* nla, const char* sspiModule);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_sspi_module_init(rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_impersonate(rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_revert_to_self(rdpNla* nla);
FREERDP_LOCAL void nla_free(rdpNla* nla);
@@ -76,9 +95,17 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpNla* nla_new(rdpContext* context, rdpTransport* transport);
FREERDP_LOCAL void nla_set_early_user_auth(rdpNla* nla, BOOL earlyUserAuth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_encrypt(rdpNla* nla, const SecBuffer* inBuffer, SecBuffer* outBuffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL nla_decrypt(rdpNla* nla, const SecBuffer* inBuffer, SecBuffer* outBuffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SECURITY_STATUS nla_QueryContextAttributes(rdpNla* nla, DWORD ulAttr, PVOID pBuffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SECURITY_STATUS nla_FreeContextBuffer(rdpNla* nla, PVOID pBuffer);
#endif /* FREERDP_LIB_CORE_NLA_H */

52
libfreerdp/core/orders.h
View File

@@ -189,97 +189,149 @@
#define CG_GLYPH_UNICODE_PRESENT 0x0010
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BYTE get_primary_drawing_order_field_bytes(UINT32 orderType, BOOL* pValid);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_recv_order(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, BYTE flags,
BYTE fieldBytes);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_bounds(wStream* s, const ORDER_INFO* orderInfo);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_dstblt_order(ORDER_INFO* orderInfo,
const DSTBLT_ORDER* dstblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
const DSTBLT_ORDER* dstblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_patblt_order(ORDER_INFO* orderInfo, PATBLT_ORDER* patblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo,
PATBLT_ORDER* patblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_scrblt_order(ORDER_INFO* orderInfo,
const SCRBLT_ORDER* scrblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
const SCRBLT_ORDER* scrblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_opaque_rect_order(ORDER_INFO* orderInfo,
const OPAQUE_RECT_ORDER* opaque_rect);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
const OPAQUE_RECT_ORDER* opaque_rect);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_line_to_order(ORDER_INFO* orderInfo,
const LINE_TO_ORDER* line_to);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_line_to_order(wStream* s, ORDER_INFO* orderInfo,
const LINE_TO_ORDER* line_to);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_memblt_order(ORDER_INFO* orderInfo,
const MEMBLT_ORDER* memblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_memblt_order(wStream* s, ORDER_INFO* orderInfo,
const MEMBLT_ORDER* memblt);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_glyph_index_order(ORDER_INFO* orderInfo,
const GLYPH_INDEX_ORDER* glyph_index);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
GLYPH_INDEX_ORDER* glyph_index);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER* cache_bitmap,
BOOL compressed, const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_bitmap_order(wStream* s,
const CACHE_BITMAP_ORDER* cache_bitmap_order,
BOOL compressed, UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_bitmap_v2_order(
CACHE_BITMAP_V2_ORDER* cache_bitmap_v2, BOOL compressed, const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_bitmap_v2_order(wStream* s,
CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order,
BOOL compressed, UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t
update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER* cache_bitmap_v3, UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_bitmap_v3_order(wStream* s,
CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order,
UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_color_table_order(
const CACHE_COLOR_TABLE_ORDER* cache_color_table, const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_color_table_order(
wStream* s, const CACHE_COLOR_TABLE_ORDER* cache_color_table_order, UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_glyph_order(const CACHE_GLYPH_ORDER* cache_glyph,
const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_glyph_order(wStream* s,
const CACHE_GLYPH_ORDER* cache_glyph_order,
UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_glyph_v2_order(
const CACHE_GLYPH_V2_ORDER* cache_glyph_v2, const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_glyph_v2_order(wStream* s,
const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_cache_brush_order(const CACHE_BRUSH_ORDER* cache_brush,
const UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_cache_brush_order(wStream* s,
const CACHE_BRUSH_ORDER* cache_brush_order,
UINT16* flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t update_approximate_create_offscreen_bitmap_order(
const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_create_offscreen_bitmap_order(
wStream* s, const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t
update_approximate_switch_surface_order(const SWITCH_SURFACE_ORDER* switch_surface);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_switch_surface_order(wStream* s,
const SWITCH_SURFACE_ORDER* switch_surface);

13
libfreerdp/core/peer.c
View File

@@ -971,13 +971,15 @@ static state_run_t peer_recv_callback_internal(WINPR_ATTR_UNUSED rdpTransport* t
switch (ret)
{
case STATE_RUN_SUCCESS:
rdp_server_transition_to_state(
rdp, CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_RESPONSE);
if (!rdp_server_transition_to_state(
rdp, CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_RESPONSE))
ret = STATE_RUN_FAILED;
break;
case STATE_RUN_CONTINUE:
/* mismatch on the supported kind of UDP transports */
rdp_server_transition_to_state(
rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
if (!rdp_server_transition_to_state(
rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE))
ret = STATE_RUN_FAILED;
break;
default:
break;
@@ -1238,7 +1240,8 @@ static BOOL freerdp_peer_close(freerdp_peer* client)
if (freerdp_settings_get_bool(context->settings, FreeRDP_SupportErrorInfoPdu))
{
rdp_send_error_info(context->rdp);
if (!rdp_send_error_info(context->rdp))
return FALSE;
}
return mcs_send_disconnect_provider_ultimatum(context->rdp->mcs,

1
libfreerdp/core/peer.h
View File

@@ -26,6 +26,7 @@
#include <freerdp/peer.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_peer_handle_state_demand_active(freerdp_peer* client);
#endif /* FREERDP_LIB_CORE_PEER_H */

11
libfreerdp/core/proxy.h
View File

@@ -23,10 +23,13 @@
#include "freerdp/settings.h"
#include <openssl/bio.h>
BOOL proxy_prepare(rdpSettings* settings, const char** lpPeerHostname, UINT16* lpPeerPort,
const char** lpProxyUsername, const char** lpProxyPassword);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL proxy_prepare(rdpSettings* settings, const char** lpPeerHostname,
UINT16* lpPeerPort, const char** lpProxyUsername,
const char** lpProxyPassword);
BOOL proxy_connect(rdpContext* context, BIO* bio, const char* proxyUsername,
const char* proxyPassword, const char* hostname, UINT16 port);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL proxy_connect(rdpContext* context, BIO* bio, const char* proxyUsername,
const char* proxyPassword, const char* hostname, UINT16 port);
#endif /* FREERDP_LIB_CORE_HTTP_PROXY_H */

53
libfreerdp/core/rdp.c
View File

@@ -632,7 +632,8 @@ BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId)
else if (reason == Disconnect_Ultimatum_user_requested)
errorInfo = ERRINFO_LOGOFF_BY_USER;
rdp_set_error_info(rdp, errorInfo);
if (!rdp_set_error_info(rdp, errorInfo))
return FALSE;
}
WLog_Print(rdp->log, WLOG_DEBUG, "DisconnectProviderUltimatum: reason: %d", reason);
@@ -840,8 +841,7 @@ BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id, UINT16 sec_flags)
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
goto fail;
security_lock(rdp);
should_unlock = TRUE;
}
@@ -864,8 +864,8 @@ BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id, UINT16 sec_flags)
rc = TRUE;
fail:
if (should_unlock && !security_unlock(rdp))
rc = FALSE;
if (should_unlock)
security_unlock(rdp);
Stream_Release(s);
return rc;
}
@@ -886,8 +886,7 @@ BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id, UINT1
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
goto fail;
security_lock(rdp);
should_unlock = TRUE;
}
@@ -916,8 +915,8 @@ BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id, UINT1
rc = TRUE;
fail:
if (should_unlock && !security_unlock(rdp))
rc = FALSE;
if (should_unlock)
security_unlock(rdp);
return rc;
}
@@ -937,8 +936,7 @@ BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id, UI
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
goto fail;
security_lock(rdp);
should_unlock = TRUE;
}
@@ -973,8 +971,8 @@ BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id, UI
rc = TRUE;
fail:
if (should_unlock && !security_unlock(rdp))
rc = FALSE;
if (should_unlock)
security_unlock(rdp);
Stream_Release(s);
return rc;
}
@@ -990,8 +988,7 @@ BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags)
if (sec_flags & SEC_ENCRYPT)
{
if (!security_lock(rdp))
goto fail;
security_lock(rdp);
should_unlock = TRUE;
}
@@ -1014,8 +1011,9 @@ BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags)
rc = TRUE;
fail:
if (should_unlock && !security_unlock(rdp))
rc = FALSE;
if (should_unlock)
security_unlock(rdp);
Stream_Release(s);
return rc;
}
@@ -1517,8 +1515,7 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
WINPR_ASSERT(s);
WINPR_ASSERT(pLength);
if (!security_lock(rdp))
return FALSE;
security_lock(rdp);
INT32 length = *pLength;
if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
@@ -1607,8 +1604,7 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
}
res = TRUE;
unlock:
if (!security_unlock(rdp))
return FALSE;
security_unlock(rdp);
return res;
}
@@ -1936,7 +1932,8 @@ static state_run_t rdp_recv_callback_int(WINPR_ATTR_UNUSED rdpTransport* transpo
}
else if (nla_get_state(rdp->nla) == NLA_STATE_POST_NEGO)
{
nego_recv(rdp->transport, s, (void*)rdp->nego);
if (nego_recv(rdp->transport, s, (void*)rdp->nego) < 0)
return STATE_RUN_FAILED;
if (!nego_update_settings_from_state(rdp->nego, rdp->settings))
return STATE_RUN_FAILED;
@@ -2114,9 +2111,11 @@ static state_run_t rdp_recv_callback_int(WINPR_ATTR_UNUSED rdpTransport* transpo
case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_REQUEST:
if (!rdp_client_connect_auto_detect(rdp, s, WLOG_DEBUG))
{
(void)rdp_client_transition_to_state(
rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
status = STATE_RUN_TRY_AGAIN;
if (!rdp_client_transition_to_state(
rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE))
status = STATE_RUN_FAILED;
else
status = STATE_RUN_TRY_AGAIN;
}
break;
@@ -2480,7 +2479,7 @@ static void rdp_reset_free(rdpRdp* rdp)
{
WINPR_ASSERT(rdp);
(void)security_lock(rdp);
security_lock(rdp);
rdp_free_rc4_decrypt_keys(rdp);
rdp_free_rc4_encrypt_keys(rdp);
@@ -2488,7 +2487,7 @@ static void rdp_reset_free(rdpRdp* rdp)
winpr_Cipher_Free(rdp->fips_decrypt);
rdp->fips_encrypt = NULL;
rdp->fips_decrypt = NULL;
(void)security_unlock(rdp);
security_unlock(rdp);
aad_free(rdp->aad);
mcs_free(rdp->mcs);

90
libfreerdp/core/rdp.h
View File

@@ -22,7 +22,15 @@
#define FREERDP_LIB_CORE_RDP_H
#include <winpr/json.h>
#include <winpr/stream.h>
#include <winpr/crypto.h>
#include <freerdp/config.h>
#include <freerdp/api.h>
#include <freerdp/license.h>
#include <freerdp/freerdp.h>
#include <freerdp/settings.h>
#include <freerdp/log.h>
#include "nla.h"
#include "aad.h"
@@ -47,14 +55,6 @@
#include "channels.h"
#include "timer.h"
#include <freerdp/freerdp.h>
#include <freerdp/settings.h>
#include <freerdp/log.h>
#include <freerdp/api.h>
#include <winpr/stream.h>
#include <winpr/crypto.h>
/* Security Header Flags */
#define SEC_EXCHANGE_PKT 0x0001
#define SEC_TRANSPORT_REQ 0x0002
@@ -209,20 +209,26 @@ struct rdp_rdp
char log_context[64];
WINPR_JSON* wellknown;
FreeRDPTimer* timer;
pGetCommonAccessToken GetCommonAccessToken;
WINPR_ATTR_NODISCARD pGetCommonAccessToken GetCommonAccessToken;
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_security_header(rdpRdp* rdp, wStream* s, UINT16* flags, UINT16* length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_write_security_header(rdpRdp* rdp, wStream* s, UINT16 flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_share_control_header(rdpRdp* rdp, wStream* s, UINT16* tpktLength,
UINT16* remainingLength, UINT16* type,
UINT16* channel_id);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_share_data_header(rdpRdp* rdp, wStream* s, UINT16* length, BYTE* type,
UINT32* share_id, BYTE* compressed_type,
UINT16* compressed_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channelId, UINT16 sec_flags);
WINPR_ATTR_MALLOC(rdp_send, 2)
@@ -233,13 +239,18 @@ WINPR_ATTR_MALLOC(Stream_Release, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* rdp_send_stream_pdu_init(rdpRdp* rdp, UINT16* sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channel_id);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channel_id,
UINT16 sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id,
UINT16 sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id,
UINT16 sec_flags);
@@ -247,41 +258,59 @@ WINPR_ATTR_MALLOC(rdp_send_data_pdu, 2)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* rdp_data_pdu_init(rdpRdp* rdp, UINT16* sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_data_pdu(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_channel_data(rdpRdp* rdp, UINT16 channelId, const BYTE* data,
size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize,
UINT32 flags, const BYTE* data, size_t chunkSize);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags);
WINPR_ATTR_MALLOC(rdp_send_message_channel_pdu, 2)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* rdp_message_channel_pdu_init(rdpRdp* rdp, UINT16* sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_message_channel_pdu(rdpRdp* rdp, wStream* s,
UINT16 securityFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s, UINT16 pduType,
UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rdp_check_fds(rdpRdp* rdp);
FREERDP_LOCAL void rdp_free(rdpRdp* rdp);
WINPR_ATTR_MALLOC(rdp_free, 1)
FREERDP_LOCAL rdpRdp* rdp_new(rdpContext* context);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_reset(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_io_callback_set_event(rdpRdp* rdp, BOOL reset);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const rdpTransportIo* rdp_get_io_callbacks(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_set_io_callbacks(rdpRdp* rdp, const rdpTransportIo* io_callbacks);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_set_io_callback_context(rdpRdp* rdp, void* usercontext);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL void* rdp_get_io_callback_context(rdpRdp* rdp);
#define RDP_TAG FREERDP_TAG("core.rdp")
@@ -294,32 +323,45 @@ FREERDP_LOCAL void* rdp_get_io_callback_context(rdpRdp* rdp);
} while (0)
#endif
const char* data_pdu_type_to_string(UINT8 type);
const char* pdu_type_to_str(UINT16 pduType, char* buffer, size_t length);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* data_pdu_type_to_string(UINT8 type);
BOOL rdp_finalize_reset_flags(rdpRdp* rdp, BOOL clearAll);
BOOL rdp_finalize_set_flag(rdpRdp* rdp, UINT32 flag);
BOOL rdp_finalize_is_flag_set(rdpRdp* rdp, UINT32 flag);
const char* rdp_finalize_flags_to_str(UINT32 flags, char* buffer, size_t size);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* pdu_type_to_str(UINT16 pduType, char* buffer,
size_t length);
BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_finalize_reset_flags(rdpRdp* rdp, BOOL clearAll);
BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo);
BOOL rdp_send_error_info(rdpRdp* rdp);
FREERDP_LOCAL BOOL rdp_finalize_set_flag(rdpRdp* rdp, UINT32 flag);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_finalize_is_flag_set(rdpRdp* rdp, UINT32 flag);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* rdp_finalize_flags_to_str(UINT32 flags, char* buffer,
size_t size);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength,
UINT16 securityFlags);
FREERDP_LOCAL BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_send_error_info(rdpRdp* rdp);
void rdp_free_rc4_encrypt_keys(rdpRdp* rdp);
BOOL rdp_reset_rc4_encrypt_keys(rdpRdp* rdp);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_reset_rc4_encrypt_keys(rdpRdp* rdp);
void rdp_free_rc4_decrypt_keys(rdpRdp* rdp);
BOOL rdp_reset_rc4_decrypt_keys(rdpRdp* rdp);
const char* rdp_security_flag_string(UINT32 securityFlags, char* buffer, size_t size);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_reset_rc4_decrypt_keys(rdpRdp* rdp);
BOOL rdp_set_backup_settings(rdpRdp* rdp);
BOOL rdp_reset_runtime_settings(rdpRdp* rdp);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* rdp_security_flag_string(UINT32 securityFlags,
char* buffer, size_t size);
void rdp_log_build_warnings(rdpRdp* rdp);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_set_backup_settings(rdpRdp* rdp);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL rdp_reset_runtime_settings(rdpRdp* rdp);
FREERDP_LOCAL void rdp_log_build_warnings(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t rdp_get_event_handles(rdpRdp* rdp, HANDLE* handles, uint32_t count);
#endif /* FREERDP_LIB_CORE_RDP_H */

2
libfreerdp/core/rdstls.h
View File

@@ -24,6 +24,7 @@ typedef struct rdp_rdstls rdpRdstls;
#include <freerdp/freerdp.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T rdstls_parse_pdu(wLog* log, wStream* s);
FREERDP_LOCAL void rdstls_free(rdpRdstls* rdstls);
@@ -32,6 +33,7 @@ WINPR_ATTR_MALLOC(rdstls_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpRdstls* rdstls_new(rdpContext* context, rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rdstls_authenticate(rdpRdstls* rdstls);
#endif /* FREERDP_LIB_CORE_RDSTLS_H */

6
libfreerdp/core/redirection.h
View File

@@ -36,15 +36,21 @@ typedef struct rdp_redirection rdpRedirection;
#define CERT_ctl_file_element 34
#define CERT_keyid_file_element 35
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int rdp_redirection_apply_settings(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL state_run_t rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL
rdp_write_enhanced_security_redirection_packet(wStream* s, const rdpRedirection* redirection);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_redirection_read_target_cert(rdpCertificate** ptargetCertificate,
const BYTE* data, size_t length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_set_target_certificate(rdpSettings* settings, const rdpCertificate* tcert);
#define REDIR_TAG FREERDP_TAG("core.redirection")

12
libfreerdp/core/security.c
View File

@@ -747,8 +747,7 @@ BOOL security_establish_keys(rdpRdp* rdp)
rdp->rc4_key_len = 16;
}
if (!security_lock(rdp))
return FALSE;
security_lock(rdp);
memcpy(rdp->decrypt_update_key, rdp->decrypt_key, 16);
memcpy(rdp->encrypt_update_key, rdp->encrypt_key, 16);
rdp->decrypt_use_count = 0;
@@ -756,7 +755,8 @@ BOOL security_establish_keys(rdpRdp* rdp)
rdp->encrypt_use_count = 0;
rdp->encrypt_checksum_use_count = 0;
return security_unlock(rdp);
security_unlock(rdp);
return TRUE;
}
static BOOL security_key_update(BYTE* key, BYTE* update_key, size_t key_len, rdpRdp* rdp)
@@ -991,16 +991,14 @@ out:
return result;
}
BOOL security_lock(rdpRdp* rdp)
void security_lock(rdpRdp* rdp)
{
WINPR_ASSERT(rdp);
EnterCriticalSection(&rdp->critical);
return TRUE;
}
BOOL security_unlock(rdpRdp* rdp)
void security_unlock(rdpRdp* rdp)
{
WINPR_ASSERT(rdp);
LeaveCriticalSection(&rdp->critical);
return TRUE;
}

30
libfreerdp/core/security.h
View File

@@ -28,41 +28,67 @@
#include <winpr/stream.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_master_secret(const BYTE* premaster_secret, size_t pre_len,
const BYTE* client_random, size_t client_len,
const BYTE* server_random, size_t server_len,
BYTE* output, size_t out_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_session_key_blob(const BYTE* master_secret, size_t master_len,
const BYTE* client_random, size_t client_len,
const BYTE* server_random, size_t server_len,
BYTE* output, size_t out_len);
FREERDP_LOCAL void security_mac_salt_key(const BYTE* session_key_blob, size_t session_len,
const BYTE* client_random, size_t client_len,
const BYTE* server_random, size_t server_len, BYTE* output,
size_t out_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_licensing_encryption_key(const BYTE* session_key_blob,
size_t session_len, const BYTE* client_random,
size_t client_len, const BYTE* server_random,
size_t server_len, BYTE* output,
size_t out_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_mac_data(const BYTE* mac_salt_key, size_t mac_salt_key_length,
const BYTE* data, size_t length, BYTE* output,
size_t output_length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_mac_signature(rdpRdp* rdp, const BYTE* data, UINT32 length,
BYTE* output, size_t out_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_salted_mac_signature(rdpRdp* rdp, const BYTE* data, UINT32 length,
BOOL encryption, BYTE* output, size_t out_len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_establish_keys(rdpRdp* rdp);
FREERDP_LOCAL BOOL security_lock(rdpRdp* rdp);
FREERDP_LOCAL BOOL security_unlock(rdpRdp* rdp);
FREERDP_LOCAL void security_lock(rdpRdp* rdp);
FREERDP_LOCAL void security_unlock(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_encrypt(BYTE* data, size_t length, rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_decrypt(BYTE* data, size_t length, rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_hmac_signature(const BYTE* data, size_t length, BYTE* output,
size_t out_len, rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_fips_encrypt(BYTE* data, size_t length, rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_fips_decrypt(BYTE* data, size_t length, rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL security_fips_check_signature(const BYTE* data, size_t length, const BYTE* sig,
size_t sig_len, rdpRdp* rdp);

130
libfreerdp/core/server.h
View File

@@ -85,183 +85,311 @@ struct WTSVirtualChannelManager
LONG dvc_channel_id_seq;
UINT16 dvc_spoken_version;
psDVCCreationStatusCallback dvc_creation_status;
WINPR_ATTR_NODISCARD psDVCCreationStatusCallback dvc_creation_status;
void* dvc_creation_status_userdata;
wHashTable* dynamicVirtualChannels;
};
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionW(LPWSTR pTargetServerName,
ULONG TargetLogonId, BYTE HotkeyVk,
USHORT HotkeyModifiers);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionA(LPSTR pTargetServerName,
ULONG TargetLogonId, BYTE HotkeyVk,
USHORT HotkeyModifiers);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExW(LPWSTR pTargetServerName,
ULONG TargetLogonId,
BYTE HotkeyVk,
USHORT HotkeyModifiers,
DWORD flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExA(LPSTR pTargetServerName,
ULONG TargetLogonId,
BYTE HotkeyVk,
USHORT HotkeyModifiers,
DWORD flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSStopRemoteControlSession(ULONG LogonId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId,
PWSTR pPassword, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId,
PSTR pPassword, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved,
DWORD Version,
PWTS_SERVER_INFOW* ppServerInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved,
DWORD Version,
PWTS_SERVER_INFOA* ppServerInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSOpenServerW(LPWSTR pServerName);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSOpenServerA(LPSTR pServerName);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSOpenServerExW(LPWSTR pServerName);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSOpenServerExA(LPSTR pServerName);
FREERDP_LOCAL VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved,
DWORD Version,
PWTS_SESSION_INFOW* ppSessionInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved,
DWORD Version,
PWTS_SESSION_INFOA* ppSessionInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateSessionsExW(HANDLE hServer, DWORD* pLevel,
DWORD Filter,
PWTS_SESSION_INFO_1W* ppSessionInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateSessionsExA(HANDLE hServer, DWORD* pLevel,
DWORD Filter,
PWTS_SESSION_INFO_1A* ppSessionInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved,
DWORD Version,
PWTS_PROCESS_INFOW* ppProcessInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved,
DWORD Version,
PWTS_PROCESS_INFOA* ppProcessInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSTerminateProcess(HANDLE hServer, DWORD ProcessId,
DWORD ExitCode);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQuerySessionInformationW(HANDLE hServer, DWORD SessionId,
WTS_INFO_CLASS WTSInfoClass,
LPWSTR* ppBuffer,
DWORD* pBytesReturned);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQuerySessionInformationA(HANDLE hServer, DWORD SessionId,
WTS_INFO_CLASS WTSInfoClass,
LPSTR* ppBuffer,
DWORD* pBytesReturned);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQueryUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
WTS_CONFIG_CLASS WTSConfigClass,
LPWSTR* ppBuffer, DWORD* pBytesReturned);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQueryUserConfigA(LPSTR pServerName, LPSTR pUserName,
WTS_CONFIG_CLASS WTSConfigClass,
LPSTR* ppBuffer, DWORD* pBytesReturned);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSetUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer,
DWORD DataLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSetUserConfigA(LPSTR pServerName, LPSTR pUserName,
WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer,
DWORD DataLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSendMessageW(HANDLE hServer, DWORD SessionId, LPWSTR pTitle,
DWORD TitleLength, LPWSTR pMessage,
DWORD MessageLength, DWORD Style, DWORD Timeout,
DWORD* pResponse, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSendMessageA(HANDLE hServer, DWORD SessionId, LPSTR pTitle,
DWORD TitleLength, LPSTR pMessage,
DWORD MessageLength, DWORD Style, DWORD Timeout,
DWORD* pResponse, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSDisconnectSession(HANDLE hServer, DWORD SessionId, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSLogoffSession(HANDLE hServer, DWORD SessionId, BOOL bWait);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSShutdownSystem(HANDLE hServer, DWORD ShutdownFlag);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSWaitSystemEvent(HANDLE hServer, DWORD EventMask,
DWORD* pEventFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSVirtualChannelOpen(HANDLE hServer, DWORD SessionId,
LPSTR pVirtualName);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE WINAPI FreeRDP_WTSVirtualChannelOpenEx(DWORD SessionId, LPSTR pVirtualName,
DWORD flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelClose(HANDLE hChannelHandle);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelRead(HANDLE hChannelHandle, ULONG TimeOut,
PCHAR Buffer, ULONG BufferSize,
PULONG pBytesRead);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer,
ULONG Length, PULONG pBytesWritten);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeInput(HANDLE hChannelHandle);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeOutput(HANDLE hChannelHandle);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSVirtualChannelQuery(HANDLE hChannelHandle,
WTS_VIRTUAL_CLASS WtsVirtualClass,
PVOID* ppBuffer, DWORD* pBytesReturned);
FREERDP_LOCAL VOID WINAPI FreeRDP_WTSFreeMemory(PVOID pMemory);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSFreeMemoryExW(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory,
ULONG NumberOfEntries);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSFreeMemoryExA(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory,
ULONG NumberOfEntries);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSRegisterSessionNotification(HWND hWnd, DWORD dwFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSUnRegisterSessionNotification(HWND hWnd);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd,
DWORD dwFlags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSUnRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQueryUserToken(ULONG SessionId, PHANDLE phToken);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateProcessesExW(HANDLE hServer, DWORD* pLevel,
DWORD SessionId, LPWSTR* ppProcessInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateProcessesExA(HANDLE hServer, DWORD* pLevel,
DWORD SessionId, LPSTR* ppProcessInfo,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateListenersW(HANDLE hServer, PVOID pReserved,
DWORD Reserved,
PWTSLISTENERNAMEW pListeners,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSEnumerateListenersA(HANDLE hServer, PVOID pReserved,
DWORD Reserved,
PWTSLISTENERNAMEA pListeners,
DWORD* pCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQueryListenerConfigW(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPWSTR pListenerName,
PWTSLISTENERCONFIGW pBuffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSQueryListenerConfigA(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPSTR pListenerName,
PWTSLISTENERCONFIGA pBuffer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSCreateListenerW(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPWSTR pListenerName,
PWTSLISTENERCONFIGW pBuffer, DWORD flag);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSCreateListenerA(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPSTR pListenerName,
PWTSLISTENERCONFIGA pBuffer, DWORD flag);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSetListenerSecurityW(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPWSTR pListenerName,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSSetListenerSecurityA(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPSTR pListenerName,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSGetListenerSecurityW(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPWSTR pListenerName,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD nLength, LPDWORD lpnLengthNeeded);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSGetListenerSecurityA(HANDLE hServer, PVOID pReserved,
DWORD Reserved, LPSTR pListenerName,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD nLength, LPDWORD lpnLengthNeeded);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL CDECL FreeRDP_WTSEnableChildSessions(BOOL bEnable);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL CDECL FreeRDP_WTSIsChildSessionsEnabled(PBOOL pbEnabled);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL CDECL FreeRDP_WTSGetChildSessionId(PULONG pSessionId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD WINAPI FreeRDP_WTSGetActiveConsoleSessionId(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSLogoffUser(HANDLE hServer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL WINAPI FreeRDP_WTSLogonUser(HANDLE hServer, LPCSTR username, LPCSTR password,
LPCSTR domain);

27
libfreerdp/core/settings.h
View File

@@ -35,47 +35,74 @@
#include <string.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_enforce_consistency(rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_enforce_monitor_exists(rdpSettings* settings);
FREERDP_LOCAL void freerdp_settings_print_warnings(const rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_check_client_after_preconnect(const rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_set_default_order_support(rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src);
FREERDP_LOCAL void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_set_string_(rdpSettings* settings,
FreeRDP_Settings_Keys_String id, const char* val,
size_t len);
FREERDP_LOCAL BOOL freerdp_settings_set_string_copy_(rdpSettings* settings,
FreeRDP_Settings_Keys_String id,
const char* val, size_t len, BOOL cleanup);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_capability_buffer_resize(rdpSettings* settings, size_t count,
BOOL force);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL identity_set_from_settings_with_pwd(SEC_WINNT_AUTH_IDENTITY_W* identity,
const rdpSettings* settings,
FreeRDP_Settings_Keys_String UserId,
FreeRDP_Settings_Keys_String DomainId,
const WCHAR* Password, size_t pwdLen);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL identity_set_from_settings(SEC_WINNT_AUTH_IDENTITY_W* identity,
const rdpSettings* settings,
FreeRDP_Settings_Keys_String UserId,
FreeRDP_Settings_Keys_String DomainId,
FreeRDP_Settings_Keys_String PwdId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL identity_set_from_smartcard_hash(SEC_WINNT_AUTH_IDENTITY_W* identity,
const rdpSettings* settings,
FreeRDP_Settings_Keys_String userId,
FreeRDP_Settings_Keys_String domainId,
FreeRDP_Settings_Keys_String pwdId,
const BYTE* certSha1, size_t sha1len);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* freerdp_settings_glyph_level_string(UINT32 level, char* buffer,
size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings,
FreeRDP_Settings_Keys_Pointer id,
FreeRDP_Settings_Keys_UInt32 lenId,
const void* data, size_t len, size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_target_net_adresses_reset(rdpSettings* settings, size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_target_net_addresses_resize(rdpSettings* settings, size_t count);
#endif /* FREERDP_LIB_CORE_SETTINGS_H */

7
libfreerdp/core/state.h
View File

@@ -36,9 +36,16 @@ typedef enum
STATE_RUN_CONTINUE = -24
} state_run_t;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL state_run_failed(state_run_t status);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL state_run_success(state_run_t status);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL state_run_continue(state_run_t status);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* state_run_result_string(state_run_t status, char* buffer,
size_t buffersize);

2
libfreerdp/core/streamdump.h
View File

@@ -26,6 +26,7 @@
#include <winpr/wtypes.h>
#include <winpr/stream.h>
WINPR_ATTR_NODISCARD
#if !defined(BUILD_TESTING_INTERNAL)
static
#else
@@ -34,6 +35,7 @@ FREERDP_LOCAL
BOOL
stream_dump_read_line(FILE* fp, wStream* s, UINT64* pts, size_t* pOffset, UINT32* flags);
WINPR_ATTR_NODISCARD
#if !defined(BUILD_TESTING_INTERNAL)
static
#else

4
libfreerdp/core/surface.h
View File

@@ -28,9 +28,13 @@
#define SURFCMD_SURFACE_BITS_HEADER_LENGTH 22
#define SURFCMD_FRAME_MARKER_LENGTH 8
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int update_recv_surfcmds(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_surfcmd_surface_bits(wStream* s, const SURFACE_BITS_COMMAND* cmd);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction,
UINT32 frameId);

23
libfreerdp/core/tcp.h
View File

@@ -54,62 +54,85 @@
#define BIO_C_WAIT_WRITE 1108
#define BIO_C_SET_HANDLE 1109
WINPR_ATTR_NODISCARD
static inline long BIO_set_socket(BIO* b, SOCKET s, long c)
{
return BIO_ctrl(b, BIO_C_SET_SOCKET, c, (void*)(intptr_t)s);
}
static inline long BIO_get_socket(BIO* b, SOCKET* c)
{
return BIO_ctrl(b, BIO_C_GET_SOCKET, 0, c);
}
static inline long BIO_get_event(BIO* b, HANDLE* c)
{
return BIO_ctrl(b, BIO_C_GET_EVENT, 0, (void*)c);
}
static inline long BIO_set_handle(BIO* b, HANDLE h)
{
return BIO_ctrl(b, BIO_C_SET_HANDLE, 0, h);
}
static inline long BIO_set_nonblock(BIO* b, long c)
{
return BIO_ctrl(b, BIO_C_SET_NONBLOCK, c, NULL);
}
WINPR_ATTR_NODISCARD
static inline long BIO_read_blocked(BIO* b)
{
return BIO_ctrl(b, BIO_C_READ_BLOCKED, 0, NULL);
}
WINPR_ATTR_NODISCARD
static inline long BIO_write_blocked(BIO* b)
{
return BIO_ctrl(b, BIO_C_WRITE_BLOCKED, 0, NULL);
}
static inline long BIO_wait_read(BIO* b, long c)
{
return BIO_ctrl(b, BIO_C_WAIT_READ, c, NULL);
}
WINPR_ATTR_NODISCARD
static inline long BIO_wait_write(BIO* b, long c)
{
return BIO_ctrl(b, BIO_C_WAIT_WRITE, c, NULL);
}
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO_METHOD* BIO_s_simple_socket(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO_METHOD* BIO_s_buffered_socket(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_tcp_set_keep_alive_mode(const rdpSettings* settings, int sockfd);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int freerdp_tcp_connect(rdpContext* context, const char* hostname, int port,
DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int freerdp_tcp_default_connect(rdpContext* context, rdpSettings* settings,
const char* hostname, int port, DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpTransportLayer*
freerdp_tcp_connect_layer(rdpContext* context, const char* hostname, int port, DWORD timeout);
WINPR_ATTR_MALLOC(free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL char* freerdp_tcp_get_peer_address(SOCKET sockfd);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL struct addrinfo* freerdp_tcp_resolve_host(const char* hostname, int port,
int ai_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL char* freerdp_tcp_address_to_string(const struct sockaddr_storage* addr, BOOL* pIPv6);
FREERDP_LOCAL BOOL freerdp_tcp_set_nodelay(wLog* log, DWORD level, int sockfd);

4
libfreerdp/core/timer.h
View File

@@ -22,6 +22,7 @@
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/freerdp.h>
typedef struct freerdp_timer_s FreeRDPTimer;
@@ -31,5 +32,8 @@ WINPR_ATTR_MALLOC(freerdp_timer_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL FreeRDPTimer* freerdp_timer_new(rdpRdp* rdp);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL bool freerdp_timer_poll(FreeRDPTimer* timer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE freerdp_timer_get_event(FreeRDPTimer* timer);

3
libfreerdp/core/timezone.h
View File

@@ -30,7 +30,10 @@
#include <winpr/stream.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_read_client_time_zone(wStream* s, rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_write_client_time_zone(wStream* s, rdpSettings* settings);
#define TIMEZONE_TAG FREERDP_TAG("core.timezone")

19
libfreerdp/core/tpdu.h
View File

@@ -44,14 +44,31 @@ enum X224_TPDU_TYPE
#define TPDU_CONNECTION_CONFIRM_LENGTH (TPKT_HEADER_LENGTH + TPDU_CONNECTION_CONFIRM_HEADER_LENGTH)
#define TPDU_DISCONNECT_REQUEST_LENGTH (TPKT_HEADER_LENGTH + TPDU_DISCONNECT_REQUEST_HEADER_LENGTH)
const char* tpdu_type_to_string(int type);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* tpdu_type_to_string(int type);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_read_header(wStream* s, BYTE* code, BYTE* li, UINT16 tpktlength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_read_connection_request(wStream* s, BYTE* li, UINT16 tpktlength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_write_connection_request(wStream* s, UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_read_connection_confirm(wStream* s, BYTE* li, UINT16 tpktlength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_write_connection_confirm(wStream* s, UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_write_disconnect_request(wStream* s, UINT16 length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_read_data(wStream* s, UINT16* li, UINT16 tpktlength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpdu_write_data(wStream* s);
#endif /* FREERDP_LIB_CORE_TPDU_H */

8
libfreerdp/core/tpkt.h
View File

@@ -28,11 +28,19 @@
#define TPKT_HEADER_LENGTH 4
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int tpkt_verify_header(wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpkt_read_header(wStream* s, UINT16* length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpkt_write_header(wStream* s, size_t length);
#define tpkt_ensure_stream_consumed(log, s, length) \
tpkt_ensure_stream_consumed_((log), (s), (length), __func__)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL tpkt_ensure_stream_consumed_(wLog* log, wStream* s, size_t length,
const char* fkt);

60
libfreerdp/core/transport.h
View File

@@ -58,8 +58,11 @@ WINPR_ATTR_MALLOC(Stream_Release, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* transport_send_stream_init(rdpTransport* transport, size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect(rdpTransport* transport, const char* hostname, UINT16 port,
DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_childsession(rdpTransport* transport);
/**! \brief Attach a socket to the transport layer
@@ -76,6 +79,7 @@ FREERDP_LOCAL BOOL transport_connect_childsession(rdpTransport* transport);
*
* \return \b TRUE in case of success, \b FALSE otherwise.
*/
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_attach(rdpTransport* transport, int sockfd);
/**! \brief Attach a transport layer
@@ -92,79 +96,134 @@ FREERDP_LOCAL BOOL transport_attach(rdpTransport* transport, int sockfd);
*
* \return \b TRUE in case of success, \b FALSE otherwise.
*/
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_attach_layer(rdpTransport* transport, rdpTransportLayer* layer);
FREERDP_LOCAL BOOL transport_disconnect(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_rdp(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_tls(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_nla(rdpTransport* transport, BOOL earlyUserAuth);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_rdstls(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_connect_aad(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_accept_rdp(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_accept_tls(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_accept_nla(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_accept_rdstls(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int transport_read_pdu(rdpTransport* transport, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int transport_write(rdpTransport* transport, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_get_public_key(rdpTransport* transport, const BYTE** data,
DWORD* length);
#if defined(WITH_FREERDP_DEPRECATED)
FREERDP_LOCAL void transport_get_fds(rdpTransport* transport, void** rfds, int* rcount);
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int transport_check_fds(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL DWORD transport_get_event_handles(rdpTransport* transport, HANDLE* events,
DWORD nCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL HANDLE transport_get_front_bio(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_blocking_mode(rdpTransport* transport, BOOL blocking);
FREERDP_LOCAL void transport_set_gateway_enabled(rdpTransport* transport, BOOL GatewayEnabled);
FREERDP_LOCAL void transport_set_nla_mode(rdpTransport* transport, BOOL NlaMode);
FREERDP_LOCAL void transport_set_rdstls_mode(rdpTransport* transport, BOOL RdstlsMode);
FREERDP_LOCAL void transport_set_aad_mode(rdpTransport* transport, BOOL AadMode);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_is_write_blocked(rdpTransport* transport);
FREERDP_LOCAL int transport_drain_output_buffer(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_io_callback_set_event(rdpTransport* transport, BOOL set);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const rdpTransportIo* transport_get_io_callbacks(const rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_io_callbacks(rdpTransport* transport,
const rdpTransportIo* io_callbacks);
FREERDP_LOCAL BOOL transport_set_nla(rdpTransport* transport, rdpNla* nla);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpNla* transport_get_nla(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_tls(rdpTransport* transport, rdpTls* tls);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpTls* transport_get_tls(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_tsg(rdpTransport* transport, rdpTsg* tsg);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpTsg* transport_get_tsg(rdpTransport* transport);
WINPR_ATTR_MALLOC(Stream_Release, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL wStream* transport_take_from_pool(rdpTransport* transport, size_t size);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT64 transport_get_bytes_sent(rdpTransport* transport, BOOL resetCount);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_have_more_bytes_to_read(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL TRANSPORT_LAYER transport_get_layer(rdpTransport* transport);
FREERDP_LOCAL BOOL transport_set_layer(rdpTransport* transport, TRANSPORT_LAYER layer);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_get_blocking(const rdpTransport* transport);
FREERDP_LOCAL BOOL transport_set_blocking(rdpTransport* transport, BOOL blocking);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_connected_event(rdpTransport* transport);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL transport_set_recv_callbacks(rdpTransport* transport, TransportRecv recv,
void* extra);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int transport_tcp_connect(rdpTransport* transport, const char* hostname, int port,
DWORD timeout);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpTransportLayer*
transport_connect_layer(rdpTransport* transport, const char* hostname, int port, DWORD timeout);
@@ -176,6 +235,7 @@ FREERDP_LOCAL rdpTransport* transport_new(rdpContext* context);
FREERDP_LOCAL void transport_set_early_user_auth_mode(rdpTransport* transport, BOOL EUAMode);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BIO_METHOD* BIO_s_transport_layer(void);
#endif /* FREERDP_LIB_CORE_TRANSPORT_H */

52
libfreerdp/core/update.c
View File

@@ -1046,14 +1046,15 @@ static BOOL s_update_begin_paint(rdpContext* context)
static BOOL s_update_end_paint(rdpContext* context)
{
wStream* s = NULL;
BOOL rc = FALSE;
WINPR_ASSERT(context);
rdp_update_internal* update = update_cast(context->update);
if (!update->us)
return FALSE;
s = update->us;
wStream* s = update->us;
Stream_SealLength(s);
Stream_SetPosition(s, update->offsetOrders);
Stream_Write_UINT16(s, update->numberOrders); /* numberOrders (2 bytes) */
@@ -1062,15 +1063,18 @@ static BOOL s_update_end_paint(rdpContext* context)
if (update->numberOrders > 0)
{
WLog_DBG(TAG, "sending %" PRIu16 " orders", update->numberOrders);
fastpath_send_update_pdu(context->rdp->fastpath, FASTPATH_UPDATETYPE_ORDERS, s, FALSE);
if (!fastpath_send_update_pdu(context->rdp->fastpath, FASTPATH_UPDATETYPE_ORDERS, s, FALSE))
goto fail;
}
update->combineUpdates = FALSE;
update->numberOrders = 0;
update->offsetOrders = 0;
update->us = NULL;
rc = TRUE;
fail:
Stream_Free(s, TRUE);
return TRUE;
return rc;
}
static BOOL update_flush(rdpContext* context)
@@ -1233,6 +1237,7 @@ static size_t update_prepare_order_info(rdpContext* context, ORDER_INFO* orderIn
return length;
}
WINPR_ATTR_NODISCARD
static int update_write_order_info(rdpContext* context, wStream* s, const ORDER_INFO* orderInfo,
size_t offset)
{
@@ -1611,7 +1616,8 @@ static BOOL update_send_dstblt(rdpContext* context, const DSTBLT_ORDER* dstblt)
if (!update_write_dstblt_order(s, &orderInfo, dstblt))
return FALSE;
update_write_order_info(context, s, &orderInfo, offset);
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1641,8 +1647,10 @@ static BOOL update_send_patblt(rdpContext* context, PATBLT_ORDER* patblt)
return FALSE;
Stream_Seek(s, headerLength);
update_write_patblt_order(s, &orderInfo, patblt);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_patblt_order(s, &orderInfo, patblt))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1671,8 +1679,10 @@ static BOOL update_send_scrblt(rdpContext* context, const SCRBLT_ORDER* scrblt)
return FALSE;
Stream_Seek(s, headerLength);
update_write_scrblt_order(s, &orderInfo, scrblt);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_scrblt_order(s, &orderInfo, scrblt))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1703,8 +1713,10 @@ static BOOL update_send_opaque_rect(rdpContext* context, const OPAQUE_RECT_ORDER
return FALSE;
Stream_Seek(s, headerLength);
update_write_opaque_rect_order(s, &orderInfo, opaque_rect);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_opaque_rect_order(s, &orderInfo, opaque_rect))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1732,8 +1744,10 @@ static BOOL update_send_line_to(rdpContext* context, const LINE_TO_ORDER* line_t
return FALSE;
Stream_Seek(s, headerLength);
update_write_line_to_order(s, &orderInfo, line_to);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_line_to_order(s, &orderInfo, line_to))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1762,8 +1776,10 @@ static BOOL update_send_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
return FALSE;
Stream_Seek(s, headerLength);
update_write_memblt_order(s, &orderInfo, memblt);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_memblt_order(s, &orderInfo, memblt))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}
@@ -1793,8 +1809,10 @@ static BOOL update_send_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyp
return FALSE;
Stream_Seek(s, headerLength);
update_write_glyph_index_order(s, &orderInfo, glyph_index);
update_write_order_info(context, s, &orderInfo, offset);
if (!update_write_glyph_index_order(s, &orderInfo, glyph_index))
return FALSE;
if (update_write_order_info(context, s, &orderInfo, offset) < 0)
return FALSE;
update->numberOrders++;
return TRUE;
}

21
libfreerdp/core/update.h
View File

@@ -120,6 +120,7 @@ typedef struct
BOOL glyph_v2;
} rdp_secondary_update_internal;
WINPR_ATTR_NODISCARD
static inline rdp_update_internal* update_cast(rdpUpdate* update)
{
union
@@ -133,6 +134,7 @@ static inline rdp_update_internal* update_cast(rdpUpdate* update)
return cnv.internal;
}
WINPR_ATTR_NODISCARD
static inline rdp_altsec_update_internal* altsec_update_cast(rdpAltSecUpdate* update)
{
union
@@ -146,6 +148,7 @@ static inline rdp_altsec_update_internal* altsec_update_cast(rdpAltSecUpdate* up
return cnv.internal;
}
WINPR_ATTR_NODISCARD
static inline rdp_primary_update_internal* primary_update_cast(rdpPrimaryUpdate* update)
{
union
@@ -159,6 +162,7 @@ static inline rdp_primary_update_internal* primary_update_cast(rdpPrimaryUpdate*
return cnv.internal;
}
WINPR_ATTR_NODISCARD
static inline rdp_secondary_update_internal* secondary_update_cast(rdpSecondaryUpdate* update)
{
union
@@ -179,11 +183,19 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpUpdate* update_new(rdpRdp* rdp);
FREERDP_LOCAL void update_reset_state(rdpUpdate* update);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_post_connect(rdpUpdate* update);
FREERDP_LOCAL void update_post_disconnect(rdpUpdate* update);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_recv_play_sound(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_recv_pointer(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_recv(rdpUpdate* update, wStream* s);
WINPR_ATTR_MALLOC(free_bitmap_update, 2)
@@ -219,13 +231,22 @@ WINPR_ATTR_MALLOC(free_pointer_cached_update, 2)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL POINTER_CACHED_UPDATE* update_read_pointer_cached(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_read_refresh_rect(rdpUpdate* update, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_read_suppress_output(rdpUpdate* update, wStream* s);
FREERDP_LOCAL void update_register_server_callbacks(rdpUpdate* update);
FREERDP_LOCAL void update_register_client_callbacks(rdpUpdate* update);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL int update_process_messages(rdpUpdate* update);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_begin_paint(rdpUpdate* update);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_end_paint(rdpUpdate* update);
#endif /* FREERDP_LIB_CORE_UPDATE_H */

50
libfreerdp/core/utils.h
View File

@@ -42,25 +42,41 @@ typedef enum
AUTH_FAILED
} auth_status;
auth_status utils_authenticate_gateway(freerdp* instance, rdp_auth_reason reason);
auth_status utils_authenticate(freerdp* instance, rdp_auth_reason reason, BOOL override);
WINPR_ATTR_NODISCARD FREERDP_LOCAL auth_status utils_authenticate_gateway(freerdp* instance,
rdp_auth_reason reason);
HANDLE utils_get_abort_event(rdpRdp* rdp);
BOOL utils_abort_event_is_set(const rdpRdp* rdp);
BOOL utils_reset_abort(rdpRdp* rdp);
BOOL utils_abort_connect(rdpRdp* rdp);
BOOL utils_sync_credentials(rdpSettings* settings, BOOL toGateway);
BOOL utils_persist_credentials(rdpSettings* settings, const rdpSettings* current);
WINPR_ATTR_NODISCARD FREERDP_LOCAL auth_status utils_authenticate(freerdp* instance,
rdp_auth_reason reason,
BOOL override);
BOOL utils_str_is_empty(const char* str);
BOOL utils_str_copy(const char* value, char** dst);
WINPR_ATTR_NODISCARD FREERDP_LOCAL HANDLE utils_get_abort_event(rdpRdp* rdp);
const char* utils_is_vsock(const char* hostname);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_abort_event_is_set(const rdpRdp* rdp);
BOOL utils_apply_gateway_policy(wLog* log, rdpContext* context, UINT32 flags, const char* module);
char* utils_redir_flags_to_string(UINT32 flags, char* buffer, size_t size);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_reset_abort(rdpRdp* rdp);
BOOL utils_reload_channels(rdpContext* context);
FREERDP_LOCAL BOOL utils_abort_connect(rdpRdp* rdp);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_sync_credentials(rdpSettings* settings,
BOOL toGateway);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_persist_credentials(rdpSettings* settings,
const rdpSettings* current);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_str_is_empty(const char* str);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_str_copy(const char* value, char** dst);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* utils_is_vsock(const char* hostname);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_apply_gateway_policy(wLog* log, rdpContext* context,
UINT32 flags,
const char* module);
WINPR_ATTR_NODISCARD FREERDP_LOCAL char* utils_redir_flags_to_string(UINT32 flags, char* buffer,
size_t size);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL utils_reload_channels(rdpContext* context);
/** @brief generate a registry key string of format 'someting\\%s\\foo'
*
@@ -72,6 +88,7 @@ BOOL utils_reload_channels(rdpContext* context);
*/
WINPR_ATTR_MALLOC(free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL
char* freerdp_getApplicatonDetailsRegKey(WINPR_FORMAT_ARG const char* fmt);
/** @brief generate a 'vendor/product' string with desired separator
@@ -83,6 +100,7 @@ char* freerdp_getApplicatonDetailsRegKey(WINPR_FORMAT_ARG const char* fmt);
*/
WINPR_ATTR_MALLOC(free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL
char* freerdp_getApplicatonDetailsCombined(char separator);
/** @brief returns if we are using default compile time 'vendor' and 'product' settings or an
@@ -91,6 +109,8 @@ char* freerdp_getApplicatonDetailsCombined(char separator);
* @return \b TRUE if \b freerdp_setApplicationDetails was called, \b FALSE otherwise.
* @version since 3.23.0
*/
WINPR_ATTR_NODISCARD BOOL freerdp_areApplicationDetailsCustomized(void);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL
BOOL freerdp_areApplicationDetailsCustomized(void);
#endif /* FREERDP_LIB_CORE_UTILS_H */

2
libfreerdp/core/window.h
View File

@@ -27,7 +27,9 @@
#include <freerdp/log.h>
#include <freerdp/api.h>
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL update_recv_altsec_window_order(rdpUpdate* update, wStream* s);
FREERDP_LOCAL void update_free_window_state(WINDOW_STATE_ORDER* window_state);
#define WND_TAG FREERDP_TAG("core.wnd")

9
libfreerdp/crypto/cert_common.h
View File

@@ -35,16 +35,25 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL cert_info_create(rdpCertInfo* dst, const BIGNUM* rsa, const BIGNUM* rsa_e);
FREERDP_LOCAL void cert_info_free(rdpCertInfo* info);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL cert_info_clone(rdpCertInfo* dst, const rdpCertInfo* src);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL cert_info_read_modulus(rdpCertInfo* info, size_t size, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL cert_info_read_exponent(rdpCertInfo* info, size_t size, wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL read_bignum(BYTE** dst, DWORD* length, const BIGNUM* num, BOOL alloc);
#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL X509* x509_from_rsa(const RSA* rsa);
#endif

5
libfreerdp/crypto/certificate.c
View File

@@ -926,8 +926,9 @@ static BOOL cert_write_rsa_signature(wStream* s, const void* sigData, size_t sig
if (!winpr_Digest(WINPR_MD_MD5, sigData, sigDataLen, signature, sizeof(signature)))
return FALSE;
crypto_rsa_private_encrypt(signature, sizeof(signature), priv_key_tssk, encryptedSignature,
sizeof(encryptedSignature));
if (crypto_rsa_private_encrypt(signature, sizeof(signature), priv_key_tssk, encryptedSignature,
sizeof(encryptedSignature)) < 0)
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT16) + sizeof(encryptedSignature) + 8))
return FALSE;

9
libfreerdp/crypto/certificate.h
View File

@@ -45,8 +45,11 @@ WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpCertificate* freerdp_certificate_new_from_x509(const X509* xcert,
const STACK_OF(X509) * chain);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_certificate_read_server_cert(rdpCertificate* certificate,
const BYTE* server_cert, size_t length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T freerdp_certificate_write_server_cert(const rdpCertificate* certificate,
UINT32 dwVersion, wStream* s);
@@ -54,16 +57,22 @@ WINPR_ATTR_MALLOC(freerdp_certificate_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpCertificate* freerdp_certificate_clone(const rdpCertificate* certificate);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const rdpCertInfo* freerdp_certificate_get_info(const rdpCertificate* certificate);
/** \brief returns a pointer to a X509 structure.
* Call X509_free when done.
*/
WINPR_ATTR_NODISCARD
FREERDP_LOCAL X509* freerdp_certificate_get_x509(rdpCertificate* certificate);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t freerdp_certificate_get_chain_len(rdpCertificate* certificate);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL X509* freerdp_certificate_get_chain_at(rdpCertificate* certificate, size_t offset);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL freerdp_certificate_publickey_encrypt(const rdpCertificate* cert,
const BYTE* input, size_t cbInput,
BYTE** poutput, size_t* pcbOutput);

7
libfreerdp/crypto/crypto.h
View File

@@ -33,15 +33,22 @@ extern "C"
{
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T crypto_rsa_public_encrypt(const BYTE* input, size_t length,
const rdpCertInfo* cert, BYTE* output,
size_t output_length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T crypto_rsa_public_decrypt(const BYTE* input, size_t length,
const rdpCertInfo* cert, BYTE* output,
size_t output_length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T crypto_rsa_private_encrypt(const BYTE* input, size_t length,
const rdpPrivateKey* key, BYTE* output,
size_t output_length);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL SSIZE_T crypto_rsa_private_decrypt(const BYTE* input, size_t length,
const rdpPrivateKey* key, BYTE* output,
size_t output_length);

7
libfreerdp/crypto/opensslcompat.h
View File

@@ -59,8 +59,11 @@
#define BIO_meth_set_destroy(b, f) (b)->destroy = (f)
#define BIO_meth_set_callback_ctrl(b, f) (b)->callback_ctrl = (f)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL
BIO_METHOD* BIO_meth_new(int type, const char* name);
void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM** d);
FREERDP_LOCAL void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM** d);
#endif /* OPENSSL < 1.1.0 || LIBRESSL */
#endif /* WITH_OPENSSL */
@@ -69,6 +72,7 @@ void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM
#if defined(LIBRESSL_VERSION_NUMBER) || \
(defined(OPENSSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER < 0x1010000fL))
WINPR_ATTR_NODISCARD
static inline STACK_OF(X509) * sk_X509_deep_copy(const STACK_OF(X509) * sk,
X509* (*copyfunc)(const X509*),
void (*freefunc)(X509*))
@@ -106,6 +110,7 @@ fail:
* While the TYPE_dup function take non const arguments
* the TYPE_sk versions require the arguments to be const...
*/
WINPR_ATTR_NODISCARD
static inline X509* X509_const_dup(const X509* x509)
{
X509* ptr = WINPR_CAST_CONST_PTR_AWAY(x509, X509*);

Some files were not shown because too many files have changed in this diff Show More