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

[warnings] make function declaration names consistent

Browse Source 
Use the same parameter names for declaration and implementation.
This commit is contained in:
Armin Novak
2026-02-25 16:05:02 +01:00
parent 8e340f84ac
commit 0531803808
48 changed files with 440 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libfreerdp/cache/bitmap.h vendored
View File

@@ -57,7 +57,7 @@ extern "C"
FREERDP_LOCAL void bitmap_cache_register_callbacks(rdpUpdate* update);
FREERDP_LOCAL void bitmap_cache_free(rdpBitmapCache* bitmap_cache);
FREERDP_LOCAL void bitmap_cache_free(rdpBitmapCache* bitmapCache);
WINPR_ATTR_MALLOC(bitmap_cache_free, 1)
WINPR_ATTR_NODISCARD

2
libfreerdp/cache/offscreen.h vendored
View File

@@ -35,7 +35,7 @@ extern "C"
#endif
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpBitmap* offscreen_cache_get(rdpOffscreenCache* offscreen_cache, UINT32 index);
FREERDP_LOCAL rdpBitmap* offscreen_cache_get(rdpOffscreenCache* offscreenCache, UINT32 index);
FREERDP_LOCAL void offscreen_cache_register_callbacks(rdpUpdate* update);

2
libfreerdp/cache/palette.h vendored
View File

@@ -47,7 +47,7 @@ extern "C"
FREERDP_LOCAL void palette_cache_register_callbacks(rdpUpdate* update);
FREERDP_LOCAL void palette_cache_free(rdpPaletteCache* palette_cache);
FREERDP_LOCAL void palette_cache_free(rdpPaletteCache* paletteCache);
WINPR_ATTR_MALLOC(palette_cache_free, 1)
WINPR_ATTR_NODISCARD

58
libfreerdp/cache/pointer.c vendored
View File

@@ -392,33 +392,33 @@ void pointer_cache_free(rdpPointerCache* pointer_cache)
}
POINTER_COLOR_UPDATE* copy_pointer_color_update(rdpContext* context,
const POINTER_COLOR_UPDATE* src)
const POINTER_COLOR_UPDATE* pointer)
{
POINTER_COLOR_UPDATE* dst = calloc(1, sizeof(POINTER_COLOR_UPDATE));
if (!dst || !src)
if (!dst || !pointer)
goto fail;
*dst = *src;
*dst = *pointer;
if (src->lengthAndMask > 0)
if (pointer->lengthAndMask > 0)
{
dst->andMaskData = calloc(src->lengthAndMask, sizeof(BYTE));
dst->andMaskData = calloc(pointer->lengthAndMask, sizeof(BYTE));
if (!dst->andMaskData)
goto fail;
memcpy(dst->andMaskData, src->andMaskData, src->lengthAndMask);
memcpy(dst->andMaskData, pointer->andMaskData, pointer->lengthAndMask);
}
if (src->lengthXorMask > 0)
if (pointer->lengthXorMask > 0)
{
dst->xorMaskData = calloc(src->lengthXorMask, sizeof(BYTE));
dst->xorMaskData = calloc(pointer->lengthXorMask, sizeof(BYTE));
if (!dst->xorMaskData)
goto fail;
memcpy(dst->xorMaskData, src->xorMaskData, src->lengthXorMask);
memcpy(dst->xorMaskData, pointer->xorMaskData, pointer->lengthXorMask);
}
return dst;
@@ -440,33 +440,33 @@ void free_pointer_color_update(rdpContext* context, POINTER_COLOR_UPDATE* pointe
}
POINTER_LARGE_UPDATE* copy_pointer_large_update(rdpContext* context,
const POINTER_LARGE_UPDATE* src)
const POINTER_LARGE_UPDATE* pointer)
{
POINTER_LARGE_UPDATE* dst = calloc(1, sizeof(POINTER_LARGE_UPDATE));
if (!dst || !src)
if (!dst || !pointer)
goto fail;
*dst = *src;
*dst = *pointer;
if (src->lengthAndMask > 0)
if (pointer->lengthAndMask > 0)
{
dst->andMaskData = calloc(src->lengthAndMask, sizeof(BYTE));
dst->andMaskData = calloc(pointer->lengthAndMask, sizeof(BYTE));
if (!dst->andMaskData)
goto fail;
memcpy(dst->andMaskData, src->andMaskData, src->lengthAndMask);
memcpy(dst->andMaskData, pointer->andMaskData, pointer->lengthAndMask);
}
if (src->lengthXorMask > 0)
if (pointer->lengthXorMask > 0)
{
dst->xorMaskData = calloc(src->lengthXorMask, sizeof(BYTE));
dst->xorMaskData = calloc(pointer->lengthXorMask, sizeof(BYTE));
if (!dst->xorMaskData)
goto fail;
memcpy(dst->xorMaskData, src->xorMaskData, src->lengthXorMask);
memcpy(dst->xorMaskData, pointer->xorMaskData, pointer->lengthXorMask);
}
return dst;
@@ -486,35 +486,35 @@ void free_pointer_large_update(rdpContext* context, POINTER_LARGE_UPDATE* pointe
free(pointer);
}
POINTER_NEW_UPDATE* copy_pointer_new_update(rdpContext* context, const POINTER_NEW_UPDATE* src)
POINTER_NEW_UPDATE* copy_pointer_new_update(rdpContext* context, const POINTER_NEW_UPDATE* pointer)
{
POINTER_NEW_UPDATE* dst = calloc(1, sizeof(POINTER_NEW_UPDATE));
if (!dst || !src)
if (!dst || !pointer)
goto fail;
*dst = *src;
*dst = *pointer;
if (src->colorPtrAttr.lengthAndMask > 0)
if (pointer->colorPtrAttr.lengthAndMask > 0)
{
dst->colorPtrAttr.andMaskData = calloc(src->colorPtrAttr.lengthAndMask, sizeof(BYTE));
dst->colorPtrAttr.andMaskData = calloc(pointer->colorPtrAttr.lengthAndMask, sizeof(BYTE));
if (!dst->colorPtrAttr.andMaskData)
goto fail;
memcpy(dst->colorPtrAttr.andMaskData, src->colorPtrAttr.andMaskData,
src->colorPtrAttr.lengthAndMask);
memcpy(dst->colorPtrAttr.andMaskData, pointer->colorPtrAttr.andMaskData,
pointer->colorPtrAttr.lengthAndMask);
}
if (src->colorPtrAttr.lengthXorMask > 0)
if (pointer->colorPtrAttr.lengthXorMask > 0)
{
dst->colorPtrAttr.xorMaskData = calloc(src->colorPtrAttr.lengthXorMask, sizeof(BYTE));
dst->colorPtrAttr.xorMaskData = calloc(pointer->colorPtrAttr.lengthXorMask, sizeof(BYTE));
if (!dst->colorPtrAttr.xorMaskData)
goto fail;
memcpy(dst->colorPtrAttr.xorMaskData, src->colorPtrAttr.xorMaskData,
src->colorPtrAttr.lengthXorMask);
memcpy(dst->colorPtrAttr.xorMaskData, pointer->colorPtrAttr.xorMaskData,
pointer->colorPtrAttr.lengthXorMask);
}
return dst;

10
libfreerdp/codec/progressive.c
View File

@@ -734,13 +734,13 @@ static inline void progressive_rfx_dwt_2d_decode_block(INT16* WINPR_RESTRICT buf
nBandL + nBandH);
}
void rfx_dwt_2d_extrapolate_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT temp)
void rfx_dwt_2d_extrapolate_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer)
{
WINPR_ASSERT(buffer);
WINPR_ASSERT(temp);
progressive_rfx_dwt_2d_decode_block(&buffer[3807], temp, 3);
progressive_rfx_dwt_2d_decode_block(&buffer[3007], temp, 2);
progressive_rfx_dwt_2d_decode_block(&buffer[0], temp, 1);
WINPR_ASSERT(dwt_buffer);
progressive_rfx_dwt_2d_decode_block(&buffer[3807], dwt_buffer, 3);
progressive_rfx_dwt_2d_decode_block(&buffer[3007], dwt_buffer, 2);
progressive_rfx_dwt_2d_decode_block(&buffer[0], dwt_buffer, 1);
}
static inline int progressive_rfx_dwt_2d_decode(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,

16
libfreerdp/codec/rfx.c
View File

@@ -2471,33 +2471,33 @@ const char* rfx_get_progressive_block_type_string(UINT16 blockType)
}
}
BOOL rfx_write_message_progressive_simple(RFX_CONTEXT* WINPR_RESTRICT context,
BOOL rfx_write_message_progressive_simple(RFX_CONTEXT* WINPR_RESTRICT rfx,
wStream* WINPR_RESTRICT s,
const RFX_MESSAGE* WINPR_RESTRICT msg)
{
WINPR_ASSERT(s);
WINPR_ASSERT(msg);
WINPR_ASSERT(context);
WINPR_ASSERT(rfx);
if (context->mode != RLGR1)
if (rfx->mode != RLGR1)
{
WLog_ERR(TAG, "error, RLGR1 mode is required!");
return FALSE;
}
if (!rfx_write_progressive_wb_sync(context, s))
if (!rfx_write_progressive_wb_sync(rfx, s))
return FALSE;
if (!rfx_write_progressive_wb_context(context, s))
if (!rfx_write_progressive_wb_context(rfx, s))
return FALSE;
if (!rfx_write_progressive_frame_begin(context, s, msg))
if (!rfx_write_progressive_frame_begin(rfx, s, msg))
return FALSE;
if (!rfx_write_progressive_region(context, s, msg))
if (!rfx_write_progressive_region(rfx, s, msg))
return FALSE;
if (!rfx_write_progressive_frame_end(context, s))
if (!rfx_write_progressive_frame_end(rfx, s))
return FALSE;
return TRUE;

25
libfreerdp/codec/rfx_quantization.c
View File

@@ -54,22 +54,23 @@ static inline BOOL rfx_quantization_decode_block(const primitives_t* WINPR_RESTR
return prims->lShiftC_16s_inplace(buffer, factor, buffer_size) == PRIMITIVES_SUCCESS;
}
void rfx_quantization_decode(INT16* WINPR_RESTRICT buffer, const UINT32* WINPR_RESTRICT quantVals)
void rfx_quantization_decode(INT16* WINPR_RESTRICT buffer,
const UINT32* WINPR_RESTRICT quantization_values)
{
const primitives_t* prims = primitives_get();
WINPR_ASSERT(buffer);
WINPR_ASSERT(quantVals);
WINPR_ASSERT(quantization_values);
rfx_quantization_decode_block(prims, &buffer[0], 1024, quantVals[8] - 1); /* HL1 */
rfx_quantization_decode_block(prims, &buffer[1024], 1024, quantVals[7] - 1); /* LH1 */
rfx_quantization_decode_block(prims, &buffer[2048], 1024, quantVals[9] - 1); /* HH1 */
rfx_quantization_decode_block(prims, &buffer[3072], 256, quantVals[5] - 1); /* HL2 */
rfx_quantization_decode_block(prims, &buffer[3328], 256, quantVals[4] - 1); /* LH2 */
rfx_quantization_decode_block(prims, &buffer[3584], 256, quantVals[6] - 1); /* HH2 */
rfx_quantization_decode_block(prims, &buffer[3840], 64, quantVals[2] - 1); /* HL3 */
rfx_quantization_decode_block(prims, &buffer[3904], 64, quantVals[1] - 1); /* LH3 */
rfx_quantization_decode_block(prims, &buffer[3968], 64, quantVals[3] - 1); /* HH3 */
rfx_quantization_decode_block(prims, &buffer[4032], 64, quantVals[0] - 1); /* LL3 */
rfx_quantization_decode_block(prims, &buffer[0], 1024, quantization_values[8] - 1); /* HL1 */
rfx_quantization_decode_block(prims, &buffer[1024], 1024, quantization_values[7] - 1); /* LH1 */
rfx_quantization_decode_block(prims, &buffer[2048], 1024, quantization_values[9] - 1); /* HH1 */
rfx_quantization_decode_block(prims, &buffer[3072], 256, quantization_values[5] - 1); /* HL2 */
rfx_quantization_decode_block(prims, &buffer[3328], 256, quantization_values[4] - 1); /* LH2 */
rfx_quantization_decode_block(prims, &buffer[3584], 256, quantization_values[6] - 1); /* HH2 */
rfx_quantization_decode_block(prims, &buffer[3840], 64, quantization_values[2] - 1); /* HL3 */
rfx_quantization_decode_block(prims, &buffer[3904], 64, quantization_values[1] - 1); /* LH3 */
rfx_quantization_decode_block(prims, &buffer[3968], 64, quantization_values[3] - 1); /* HH3 */
rfx_quantization_decode_block(prims, &buffer[4032], 64, quantization_values[0] - 1); /* LL3 */
}
static inline void rfx_quantization_encode_block(INT16* WINPR_RESTRICT buffer, size_t buffer_size,

12
libfreerdp/common/assistance.c
View File

@@ -1009,17 +1009,17 @@ fail:
return rc;
}
BYTE* freerdp_assistance_hex_string_to_bin(const void* raw, size_t* size)
BYTE* freerdp_assistance_hex_string_to_bin(const void* str, size_t* size)
{
BYTE* buffer = NULL;
if (!raw || !size)
if (!str || !size)
return NULL;
*size = 0;
const size_t length = strlen(raw);
const size_t length = strlen(str);
buffer = calloc(length, sizeof(BYTE));
if (!buffer)
return NULL;
const size_t rc = winpr_HexStringToBinBuffer(raw, length, buffer, length);
const size_t rc = winpr_HexStringToBinBuffer(str, length, buffer, length);
if (rc == 0)
{
free(buffer);
@@ -1029,9 +1029,9 @@ BYTE* freerdp_assistance_hex_string_to_bin(const void* raw, size_t* size)
return buffer;
}
char* freerdp_assistance_bin_to_hex_string(const void* raw, size_t size)
char* freerdp_assistance_bin_to_hex_string(const void* data, size_t size)
{
return winpr_BinToHexString(raw, size, FALSE);
return winpr_BinToHexString(data, size, FALSE);
}
static int freerdp_assistance_parse_uploadinfo(rdpAssistanceFile* file, char* uploadinfo,

24
libfreerdp/common/settings.c
View File

@@ -2062,25 +2062,25 @@ BOOL freerdp_target_net_addresses_copy(rdpSettings* settings, char** addresses,
return TRUE;
}
BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* other)
{
if (!what && !expect)
if (!what && !other)
return TRUE;
if (!what || !expect)
if (!what || !other)
return FALSE;
if (what->Id != expect->Id)
if (what->Id != other->Id)
return FALSE;
if (what->Type != expect->Type)
if (what->Type != other->Type)
return FALSE;
if (what->Name && expect->Name)
if (what->Name && other->Name)
{
if (strcmp(what->Name, expect->Name) != 0)
if (strcmp(what->Name, other->Name) != 0)
return FALSE;
}
else
{
if (what->Name != expect->Name)
if (what->Name != other->Name)
return FALSE;
}
@@ -2089,7 +2089,7 @@ BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
case RDPDR_DTYP_PRINT:
{
const RDPDR_PRINTER* a = (const RDPDR_PRINTER*)what;
const RDPDR_PRINTER* b = (const RDPDR_PRINTER*)expect;
const RDPDR_PRINTER* b = (const RDPDR_PRINTER*)other;
if (a->DriverName && b->DriverName)
return strcmp(a->DriverName, b->DriverName) == 0;
return a->DriverName == b->DriverName;
@@ -2098,7 +2098,7 @@ BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
case RDPDR_DTYP_SERIAL:
{
const RDPDR_SERIAL* a = (const RDPDR_SERIAL*)what;
const RDPDR_SERIAL* b = (const RDPDR_SERIAL*)expect;
const RDPDR_SERIAL* b = (const RDPDR_SERIAL*)other;
if (a->Path && b->Path)
{
@@ -2123,7 +2123,7 @@ BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
case RDPDR_DTYP_PARALLEL:
{
const RDPDR_PARALLEL* a = (const RDPDR_PARALLEL*)what;
const RDPDR_PARALLEL* b = (const RDPDR_PARALLEL*)expect;
const RDPDR_PARALLEL* b = (const RDPDR_PARALLEL*)other;
if (a->Path && b->Path)
return strcmp(a->Path, b->Path) == 0;
return a->Path == b->Path;
@@ -2134,7 +2134,7 @@ BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
case RDPDR_DTYP_FILESYSTEM:
{
const RDPDR_DRIVE* a = (const RDPDR_DRIVE*)what;
const RDPDR_DRIVE* b = (const RDPDR_DRIVE*)expect;
const RDPDR_DRIVE* b = (const RDPDR_DRIVE*)other;
if (a->automount != b->automount)
return FALSE;
if (a->Path && b->Path)

5
libfreerdp/core/credssp_auth.c
View File

@@ -135,12 +135,13 @@ static BOOL credssp_auth_update_name_cache(rdpCredsspAuth* auth, TCHAR* name)
#endif
return TRUE;
}
rdpCredsspAuth* credssp_auth_new(const rdpContext* rdp_ctx)
rdpCredsspAuth* credssp_auth_new(const rdpContext* context)
{
WINPR_ASSERT(context);
rdpCredsspAuth* auth = calloc(1, sizeof(rdpCredsspAuth));
if (auth)
auth->rdp_ctx = rdp_ctx;
auth->rdp_ctx = context;
return auth;
}

2
libfreerdp/core/fastpath.h
View File

@@ -149,7 +149,7 @@ FREERDP_LOCAL wStream* fastpath_input_pdu_init(rdpFastPath* fastpath, BYTE event
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s,
size_t iEventCount, UINT16 sec_flags);
size_t iNumEvents, UINT16 sec_flags);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL fastpath_send_input_pdu(rdpFastPath* fastpath, wStream* s, UINT16 sec_flags);

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

@@ -104,7 +104,7 @@ FREERDP_LOCAL BOOL http_context_set_rdg_connection_id(HttpContext* context,
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL http_context_set_rdg_correlation_id(HttpContext* context,
const GUID* RdgConnectionId);
const GUID* RdgCorrelationId);
WINPR_ATTR_NODISCARD
WINPR_ATTR_FORMAT_ARG(3, 4)

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

@@ -29,7 +29,7 @@
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);
FREERDP_LOCAL void rpc_client_call_free(RpcClientCall* clientCall);
WINPR_ATTR_MALLOC(rpc_client_call_free, 1)
WINPR_ATTR_NODISCARD

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

@@ -26,9 +26,9 @@
FREERDP_LOCAL int rpc_recv_fault_pdu(UINT32 status);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rpc_error_to_string(UINT32 error);
FREERDP_LOCAL const char* rpc_error_to_string(UINT32 code);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* rpc_error_to_category(UINT32 error);
FREERDP_LOCAL const char* rpc_error_to_category(UINT32 code);
#endif /* FREERDP_LIB_CORE_GATEWAY_RPC_FAULT_H */

11
libfreerdp/core/rdp.c
View File

@@ -820,14 +820,7 @@ static UINT32 rdp_get_sec_bytes(rdpRdp* rdp, UINT16 sec_flags)
return sec_bytes;
}
/**
* Send an RDP packet.
* @param rdp RDP module
* @param s stream
* @param channel_id channel id
*/
BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id, UINT16 sec_flags)
BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channelId, UINT16 sec_flags)
{
BOOL rc = FALSE;
UINT32 pad = 0;
@@ -848,7 +841,7 @@ BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id, UINT16 sec_flags)
{
size_t length = Stream_GetPosition(s);
Stream_SetPosition(s, 0);
if (!rdp_write_header(rdp, s, length, channel_id, sec_flags))
if (!rdp_write_header(rdp, s, length, channelId, sec_flags))
goto fail;
if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))

8
libfreerdp/core/rdp.h
View File

@@ -225,8 +225,8 @@ FREERDP_LOCAL BOOL rdp_read_share_control_header(rdpRdp* rdp, wStream* s, UINT16
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);
UINT32* shareId, BYTE* compressedType,
UINT16* compressedLength);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channelId, UINT16 sec_flags);
@@ -240,10 +240,10 @@ 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);
FREERDP_LOCAL BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channel_id,
FREERDP_LOCAL BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channelId,
UINT16 sec_flags);
WINPR_ATTR_NODISCARD

113
libfreerdp/core/settings.c
View File

@@ -183,7 +183,7 @@ static BOOL settings_reg_query_bool(rdpSettings* settings, FreeRDP_Settings_Keys
if (!settings_reg_query_dword_val(hKey, sub, &dwValue))
return FALSE;
return freerdp_settings_set_bool(settings, id, dwValue != 0 ? TRUE : FALSE);
return freerdp_settings_set_bool(settings, id, (dwValue != 0));
}
static void settings_client_load_hkey_local_machine(rdpSettings* settings)
@@ -812,8 +812,8 @@ char* freerdp_settings_get_config_path(void)
rdpSettings* freerdp_settings_new(DWORD flags)
{
const BOOL server = (flags & FREERDP_SETTINGS_SERVER_MODE) != 0 ? TRUE : FALSE;
const BOOL remote = (flags & FREERDP_SETTINGS_REMOTE_MODE) != 0 ? TRUE : FALSE;
const BOOL server = ((flags & FREERDP_SETTINGS_SERVER_MODE) != 0);
const BOOL remote = ((flags & FREERDP_SETTINGS_REMOTE_MODE) != 0);
rdpSettings* settings = (rdpSettings*)calloc(1, sizeof(rdpSettings));
if (!settings)
@@ -1378,11 +1378,11 @@ void freerdp_settings_free(rdpSettings* settings)
free(settings);
}
static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSettings* settings)
static BOOL freerdp_settings_int_buffer_copy(rdpSettings* dst, const rdpSettings* settings)
{
BOOL rc = FALSE;
if (!_settings || !settings)
if (!dst || !settings)
return FALSE;
typedef struct
@@ -1412,11 +1412,11 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
UINT32 n = freerdp_settings_get_uint32(settings, keys->lenKey);
const void* ptr = freerdp_settings_get_pointer(settings, keys->pointerKey);
if (!freerdp_settings_set_pointer_len(_settings, keys->pointerKey, ptr, n))
if (!freerdp_settings_set_pointer_len(dst, keys->pointerKey, ptr, n))
goto out_fail;
}
if (!freerdp_server_license_issuers_copy(_settings, settings->ServerLicenseProductIssuers,
if (!freerdp_server_license_issuers_copy(dst, settings->ServerLicenseProductIssuers,
settings->ServerLicenseProductIssuersCount))
goto out_fail;
@@ -1425,12 +1425,12 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
rdpCertificate* cert = freerdp_certificate_clone(settings->RdpServerCertificate);
if (!cert)
goto out_fail;
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerCertificate, cert, 1))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_RdpServerCertificate, cert, 1))
goto out_fail;
}
else
{
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerCertificate, NULL, 0))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_RdpServerCertificate, NULL, 0))
goto out_fail;
}
@@ -1439,37 +1439,36 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
rdpPrivateKey* key = freerdp_key_clone(settings->RdpServerRsaKey);
if (!key)
goto out_fail;
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerRsaKey, key, 1))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_RdpServerRsaKey, key, 1))
goto out_fail;
}
else
{
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerRsaKey, NULL, 0))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_RdpServerRsaKey, NULL, 0))
goto out_fail;
}
if (!freerdp_settings_set_uint32(_settings, FreeRDP_ChannelCount,
if (!freerdp_settings_set_uint32(dst, FreeRDP_ChannelCount,
freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount)))
goto out_fail;
if (settings->OrderSupport)
{
_settings->OrderSupport = calloc(32, sizeof(BYTE));
if (!_settings->OrderSupport)
dst->OrderSupport = calloc(32, sizeof(BYTE));
if (!dst->OrderSupport)
goto out_fail;
CopyMemory(_settings->OrderSupport, settings->OrderSupport, 32);
CopyMemory(dst->OrderSupport, settings->OrderSupport, 32);
}
if (!freerdp_capability_buffer_copy(_settings, settings))
if (!freerdp_capability_buffer_copy(dst, settings))
goto out_fail;
{
const UINT32 glyphCacheCount = 10;
const GLYPH_CACHE_DEFINITION* glyphCache =
freerdp_settings_get_pointer(settings, FreeRDP_GlyphCache);
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_GlyphCache, glyphCache,
glyphCacheCount))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_GlyphCache, glyphCache, glyphCacheCount))
goto out_fail;
}
@@ -1477,30 +1476,29 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
const UINT32 fragCacheCount = 1;
const GLYPH_CACHE_DEFINITION* fragCache =
freerdp_settings_get_pointer(settings, FreeRDP_FragCache);
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_FragCache, fragCache,
fragCacheCount))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_FragCache, fragCache, fragCacheCount))
goto out_fail;
}
if (!freerdp_settings_set_pointer_len(
_settings, FreeRDP_ClientAutoReconnectCookie,
dst, FreeRDP_ClientAutoReconnectCookie,
freerdp_settings_get_pointer(settings, FreeRDP_ClientAutoReconnectCookie), 1))
goto out_fail;
if (!freerdp_settings_set_pointer_len(
_settings, FreeRDP_ServerAutoReconnectCookie,
dst, FreeRDP_ServerAutoReconnectCookie,
freerdp_settings_get_pointer(settings, FreeRDP_ServerAutoReconnectCookie), 1))
goto out_fail;
{
const TIME_ZONE_INFORMATION* tz =
freerdp_settings_get_pointer(settings, FreeRDP_ClientTimeZone);
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_ClientTimeZone, tz, 1))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_ClientTimeZone, tz, 1))
goto out_fail;
}
{
const UINT32 nrports = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
if (!freerdp_target_net_adresses_reset(_settings, nrports))
if (!freerdp_target_net_adresses_reset(dst, nrports))
goto out_fail;
for (UINT32 i = 0; i < nrports; i++)
@@ -1510,10 +1508,9 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
const UINT32* port =
freerdp_settings_get_pointer_array(settings, FreeRDP_TargetNetPorts, i);
if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_TargetNetAddresses, i,
address))
if (!freerdp_settings_set_pointer_array(dst, FreeRDP_TargetNetAddresses, i, address))
goto out_fail;
if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_TargetNetPorts, i, port))
if (!freerdp_settings_set_pointer_array(dst, FreeRDP_TargetNetPorts, i, port))
goto out_fail;
}
}
@@ -1524,9 +1521,9 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
if (len < count)
goto out_fail;
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_DeviceArray, NULL, len))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_DeviceArray, NULL, len))
goto out_fail;
if (!freerdp_settings_set_uint32(_settings, FreeRDP_DeviceCount, count))
if (!freerdp_settings_set_uint32(dst, FreeRDP_DeviceCount, count))
goto out_fail;
for (size_t index = 0; index < count; index++)
@@ -1534,21 +1531,21 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
const RDPDR_DEVICE* argv =
freerdp_settings_get_pointer_array(settings, FreeRDP_DeviceArray, index);
WINPR_ASSERT(argv);
if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_DeviceArray, index, argv))
if (!freerdp_settings_set_pointer_array(dst, FreeRDP_DeviceArray, index, argv))
goto out_fail;
}
WINPR_ASSERT(_settings->DeviceArray || (len == 0));
WINPR_ASSERT(dst->DeviceArray || (len == 0));
WINPR_ASSERT(len >= count);
}
{
const UINT32 len = freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelArraySize);
const UINT32 len = freerdp_settings_get_uint32(dst, FreeRDP_StaticChannelArraySize);
const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
if (len < count)
goto out_fail;
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_StaticChannelArray, NULL, len))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_StaticChannelArray, NULL, len))
goto out_fail;
if (!freerdp_settings_set_uint32(_settings, FreeRDP_StaticChannelCount, count))
if (!freerdp_settings_set_uint32(dst, FreeRDP_StaticChannelCount, count))
goto out_fail;
for (size_t index = 0; index < count; index++)
@@ -1556,20 +1553,19 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
const ADDIN_ARGV* argv =
freerdp_settings_get_pointer_array(settings, FreeRDP_StaticChannelArray, index);
WINPR_ASSERT(argv);
if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_StaticChannelArray, index,
argv))
if (!freerdp_settings_set_pointer_array(dst, FreeRDP_StaticChannelArray, index, argv))
goto out_fail;
}
}
{
const UINT32 len = freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelArraySize);
const UINT32 len = freerdp_settings_get_uint32(dst, FreeRDP_DynamicChannelArraySize);
const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
if (len < count)
goto out_fail;
if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_DynamicChannelArray, NULL, len))
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_DynamicChannelArray, NULL, len))
goto out_fail;
if (!freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelCount, count))
if (!freerdp_settings_set_uint32(dst, FreeRDP_DynamicChannelCount, count))
goto out_fail;
for (size_t index = 0; index < count; index++)
@@ -1577,57 +1573,56 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe
const ADDIN_ARGV* argv =
freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
WINPR_ASSERT(argv);
if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_DynamicChannelArray, index,
argv))
if (!freerdp_settings_set_pointer_array(dst, FreeRDP_DynamicChannelArray, index, argv))
goto out_fail;
}
}
rc = freerdp_settings_set_string(_settings, FreeRDP_ActionScript,
rc = freerdp_settings_set_string(dst, FreeRDP_ActionScript,
freerdp_settings_get_string(settings, FreeRDP_ActionScript));
out_fail:
return rc;
}
BOOL freerdp_settings_copy(rdpSettings* _settings, const rdpSettings* settings)
BOOL freerdp_settings_copy(rdpSettings* dst, const rdpSettings* src)
{
BOOL rc = 0;
if (!settings || !_settings)
if (!dst || !src)
return FALSE;
/* This is required to free all non string buffers */
freerdp_settings_free_internal(_settings);
freerdp_settings_free_internal(dst);
/* This copies everything except allocated non string buffers. reset all allocated buffers to
* NULL to fix issues during cleanup */
rc = freerdp_settings_clone_keys(_settings, settings);
rc = freerdp_settings_clone_keys(dst, src);
if (!rc)
goto out_fail;
freerdp_settings_free_internal_ensure_reset(_settings);
freerdp_settings_free_internal_ensure_reset(dst);
/* Begin copying */
if (!freerdp_settings_int_buffer_copy(_settings, settings))
if (!freerdp_settings_int_buffer_copy(dst, src))
goto out_fail;
return TRUE;
out_fail:
freerdp_settings_free_internal(_settings);
freerdp_settings_free_internal(dst);
return FALSE;
}
rdpSettings* freerdp_settings_clone(const rdpSettings* settings)
{
rdpSettings* _settings = (rdpSettings*)calloc(1, sizeof(rdpSettings));
rdpSettings* dst = (rdpSettings*)calloc(1, sizeof(rdpSettings));
if (!freerdp_settings_copy(_settings, settings))
if (!freerdp_settings_copy(dst, settings))
goto out_fail;
return _settings;
return dst;
out_fail:
WINPR_PRAGMA_DIAG_PUSH
WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
freerdp_settings_free(_settings);
freerdp_settings_free(dst);
WINPR_PRAGMA_DIAG_POP
return NULL;
}
@@ -1661,9 +1656,7 @@ BOOL identity_set_from_settings_with_pwd(SEC_WINNT_AUTH_IDENTITY* identity,
Password, pwdLen);
zfree(Username, UserLen);
zfree(Domain, DomainLen);
if (rc < 0)
return FALSE;
return TRUE;
return (rc >= 0);
}
BOOL identity_set_from_settings(SEC_WINNT_AUTH_IDENTITY_W* identity, const rdpSettings* settings,
@@ -1710,14 +1703,10 @@ BOOL identity_set_from_smartcard_hash(SEC_WINNT_AUTH_IDENTITY_W* identity,
identity, marshalledCredentials, _wcslen(marshalledCredentials), NULL, 0, Password, pwdLen);
zfree(Password, pwdLen);
CredFree(marshalledCredentials);
if (rc < 0)
return FALSE;
return (rc >= 0);
#else
if (!identity_set_from_settings(identity, settings, userId, domainId, pwdId))
return FALSE;
return identity_set_from_settings(identity, settings, userId, domainId, pwdId);
#endif /* _WIN32 */
return TRUE;
}
const char* freerdp_settings_glyph_level_string(UINT32 level, char* buffer, size_t size)

8
libfreerdp/core/smartcardlogon.c
View File

@@ -109,18 +109,18 @@ void smartcardCertInfo_Free(SmartcardCertInfo* scCert)
free(scCert);
}
void smartcardCertList_Free(SmartcardCertInfo** cert_list, size_t count)
void smartcardCertList_Free(SmartcardCertInfo** pscCert, size_t count)
{
if (!cert_list)
if (!pscCert)
return;
for (size_t i = 0; i < count; i++)
{
SmartcardCertInfo* cert = cert_list[i];
SmartcardCertInfo* cert = pscCert[i];
smartcardCertInfo_Free(cert);
}
free((void*)cert_list);
free((void*)pscCert);
}
static BOOL add_cert_to_list(SmartcardCertInfo*** certInfoList, size_t* count,

4
libfreerdp/crypto/x509_utils.c
View File

@@ -518,12 +518,12 @@ void x509_utils_dns_names_free(size_t count, size_t* lengths, char** dns_names)
}
}
char** x509_utils_get_dns_names(const X509* x509, size_t* count, size_t** lengths)
char** x509_utils_get_dns_names(const X509* xcert, size_t* count, size_t** lengths)
{
char** result = 0;
string_list list = WINPR_C_ARRAY_INIT;
string_list_initialize(&list);
map_subject_alt_name(x509, GEN_DNS, extract_string, &list);
map_subject_alt_name(xcert, GEN_DNS, extract_string, &list);
(*count) = list.count;
if (list.count <= 0)

2
libfreerdp/crypto/x509_utils.h
View File

@@ -81,7 +81,7 @@ extern "C"
FREERDP_LOCAL void x509_utils_dns_names_free(size_t count, size_t* lengths, char** dns_names);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL x509_utils_check_eku(const X509* scert, int nid);
FREERDP_LOCAL BOOL x509_utils_check_eku(const X509* xcert, int nid);
FREERDP_LOCAL void x509_utils_print_info(const X509* xcert);

2
libfreerdp/gdi/gdi.h
View File

@@ -30,7 +30,7 @@
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL gdi_bitmap_update(rdpContext* context, const BITMAP_UPDATE* bitmapUpdate);
FREERDP_LOCAL void gdi_bitmap_free_ex(gdiBitmap* gdi_bmp);
FREERDP_LOCAL void gdi_bitmap_free_ex(gdiBitmap* bitmap);
WINPR_ATTR_MALLOC(gdi_bitmap_free_ex, 1)
WINPR_ATTR_NODISCARD

77
libfreerdp/utils/cliprdr_utils.c
View File

@@ -111,62 +111,63 @@ out:
return result;
}
BOOL cliprdr_read_filedescriptor(wStream* s, FILEDESCRIPTORW* file)
BOOL cliprdr_read_filedescriptor(wStream* s, FILEDESCRIPTORW* descriptor)
{
UINT64 tmp = 0;
WINPR_ASSERT(file);
WINPR_ASSERT(descriptor);
if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(FILEDESCRIPTORW)))
return FALSE;
Stream_Read_UINT32(s, file->dwFlags); /* flags (4 bytes) */
Stream_Read_UINT32(s, file->clsid.Data1);
Stream_Read_UINT16(s, file->clsid.Data2);
Stream_Read_UINT16(s, file->clsid.Data3);
Stream_Read(s, &file->clsid.Data4, sizeof(file->clsid.Data4));
Stream_Read_INT32(s, file->sizel.cx);
Stream_Read_INT32(s, file->sizel.cy);
Stream_Read_INT32(s, file->pointl.x);
Stream_Read_INT32(s, file->pointl.y);
Stream_Read_UINT32(s, file->dwFileAttributes); /* fileAttributes (4 bytes) */
Stream_Read_UINT32(s, descriptor->dwFlags); /* flags (4 bytes) */
Stream_Read_UINT32(s, descriptor->clsid.Data1);
Stream_Read_UINT16(s, descriptor->clsid.Data2);
Stream_Read_UINT16(s, descriptor->clsid.Data3);
Stream_Read(s, &descriptor->clsid.Data4, sizeof(descriptor->clsid.Data4));
Stream_Read_INT32(s, descriptor->sizel.cx);
Stream_Read_INT32(s, descriptor->sizel.cy);
Stream_Read_INT32(s, descriptor->pointl.x);
Stream_Read_INT32(s, descriptor->pointl.y);
Stream_Read_UINT32(s, descriptor->dwFileAttributes); /* fileAttributes (4 bytes) */
Stream_Read_UINT64(s, tmp); /* ftCreationTime (8 bytes) */
file->ftCreationTime = uint64_to_filetime(tmp);
descriptor->ftCreationTime = uint64_to_filetime(tmp);
Stream_Read_UINT64(s, tmp); /* ftLastAccessTime (8 bytes) */
file->ftLastAccessTime = uint64_to_filetime(tmp);
descriptor->ftLastAccessTime = uint64_to_filetime(tmp);
Stream_Read_UINT64(s, tmp); /* lastWriteTime (8 bytes) */
file->ftLastWriteTime = uint64_to_filetime(tmp);
Stream_Read_UINT32(s, file->nFileSizeHigh); /* fileSizeHigh (4 bytes) */
Stream_Read_UINT32(s, file->nFileSizeLow); /* fileSizeLow (4 bytes) */
Stream_Read_UTF16_String(s, file->cFileName,
ARRAYSIZE(file->cFileName)); /* cFileName (520 bytes) */
descriptor->ftLastWriteTime = uint64_to_filetime(tmp);
Stream_Read_UINT32(s, descriptor->nFileSizeHigh); /* fileSizeHigh (4 bytes) */
Stream_Read_UINT32(s, descriptor->nFileSizeLow); /* fileSizeLow (4 bytes) */
Stream_Read_UTF16_String(s, descriptor->cFileName,
ARRAYSIZE(descriptor->cFileName)); /* cFileName (520 bytes) */
return TRUE;
}
BOOL cliprdr_write_filedescriptor(wStream* s, const FILEDESCRIPTORW* file)
BOOL cliprdr_write_filedescriptor(wStream* s, const FILEDESCRIPTORW* descriptor)
{
WINPR_ASSERT(file);
WINPR_ASSERT(descriptor);
if (!Stream_EnsureRemainingCapacity(s, sizeof(FILEDESCRIPTORW)))
return FALSE;
Stream_Write_UINT32(s, file->dwFlags); /* flags (4 bytes) */
Stream_Write_UINT32(s, descriptor->dwFlags); /* flags (4 bytes) */
Stream_Write_UINT32(s, file->clsid.Data1);
Stream_Write_UINT16(s, file->clsid.Data2);
Stream_Write_UINT16(s, file->clsid.Data3);
Stream_Write(s, &file->clsid.Data4, sizeof(file->clsid.Data4));
Stream_Write_INT32(s, file->sizel.cx);
Stream_Write_INT32(s, file->sizel.cy);
Stream_Write_INT32(s, file->pointl.x);
Stream_Write_INT32(s, file->pointl.y);
Stream_Write_UINT32(s, file->dwFileAttributes); /* fileAttributes (4 bytes) */
Stream_Write_UINT64(s, filetime_to_uint64(file->ftCreationTime));
Stream_Write_UINT64(s, filetime_to_uint64(file->ftLastAccessTime));
Stream_Write_UINT64(s, filetime_to_uint64(file->ftLastWriteTime)); /* lastWriteTime (8 bytes) */
Stream_Write_UINT32(s, file->nFileSizeHigh); /* fileSizeHigh (4 bytes) */
Stream_Write_UINT32(s, file->nFileSizeLow); /* fileSizeLow (4 bytes) */
Stream_Write_UTF16_String(s, file->cFileName,
ARRAYSIZE(file->cFileName)); /* cFileName (520 bytes) */
Stream_Write_UINT32(s, descriptor->clsid.Data1);
Stream_Write_UINT16(s, descriptor->clsid.Data2);
Stream_Write_UINT16(s, descriptor->clsid.Data3);
Stream_Write(s, &descriptor->clsid.Data4, sizeof(descriptor->clsid.Data4));
Stream_Write_INT32(s, descriptor->sizel.cx);
Stream_Write_INT32(s, descriptor->sizel.cy);
Stream_Write_INT32(s, descriptor->pointl.x);
Stream_Write_INT32(s, descriptor->pointl.y);
Stream_Write_UINT32(s, descriptor->dwFileAttributes); /* fileAttributes (4 bytes) */
Stream_Write_UINT64(s, filetime_to_uint64(descriptor->ftCreationTime));
Stream_Write_UINT64(s, filetime_to_uint64(descriptor->ftLastAccessTime));
Stream_Write_UINT64(
s, filetime_to_uint64(descriptor->ftLastWriteTime)); /* lastWriteTime (8 bytes) */
Stream_Write_UINT32(s, descriptor->nFileSizeHigh); /* fileSizeHigh (4 bytes) */
Stream_Write_UINT32(s, descriptor->nFileSizeLow); /* fileSizeLow (4 bytes) */
Stream_Write_UTF16_String(s, descriptor->cFileName,
ARRAYSIZE(descriptor->cFileName)); /* cFileName (520 bytes) */
return TRUE;
}

8
libfreerdp/utils/rdpdr_utils.c
View File

@@ -496,14 +496,14 @@ static void rdpdr_dump_packet(wLog* log, DWORD lvl, wStream* s, const char* cust
Stream_SetPosition(s, gpos);
}
void rdpdr_dump_received_packet(wLog* log, DWORD lvl, wStream* s, const char* custom)
void rdpdr_dump_received_packet(wLog* log, DWORD lvl, wStream* out, const char* custom)
{
rdpdr_dump_packet(log, lvl, s, custom, FALSE);
rdpdr_dump_packet(log, lvl, out, custom, FALSE);
}
void rdpdr_dump_send_packet(wLog* log, DWORD lvl, wStream* s, const char* custom)
void rdpdr_dump_send_packet(wLog* log, DWORD lvl, wStream* out, const char* custom)
{
rdpdr_dump_packet(log, lvl, s, custom, TRUE);
rdpdr_dump_packet(log, lvl, out, custom, TRUE);
}
const char* rdpdr_irp_string(UINT32 major)

165
libfreerdp/utils/ringbuffer.c
View File

@@ -39,62 +39,62 @@
} while (0)
#endif
BOOL ringbuffer_init(RingBuffer* rb, size_t initialSize)
BOOL ringbuffer_init(RingBuffer* ringbuffer, size_t initialSize)
{
WINPR_ASSERT(rb);
rb->buffer = malloc(initialSize);
WINPR_ASSERT(ringbuffer);
ringbuffer->buffer = malloc(initialSize);
if (!rb->buffer)
if (!ringbuffer->buffer)
return FALSE;
rb->readPtr = rb->writePtr = 0;
rb->initialSize = rb->size = rb->freeSize = initialSize;
ringbuffer->readPtr = ringbuffer->writePtr = 0;
ringbuffer->initialSize = ringbuffer->size = ringbuffer->freeSize = initialSize;
DEBUG_RINGBUFFER("ringbuffer_init(%p)", (void*)rb);
return TRUE;
}
size_t ringbuffer_used(const RingBuffer* rb)
size_t ringbuffer_used(const RingBuffer* ringbuffer)
{
WINPR_ASSERT(rb);
return rb->size - rb->freeSize;
WINPR_ASSERT(ringbuffer);
return ringbuffer->size - ringbuffer->freeSize;
}
size_t ringbuffer_capacity(const RingBuffer* rb)
size_t ringbuffer_capacity(const RingBuffer* ringbuffer)
{
WINPR_ASSERT(rb);
return rb->size;
WINPR_ASSERT(ringbuffer);
return ringbuffer->size;
}
void ringbuffer_destroy(RingBuffer* rb)
void ringbuffer_destroy(RingBuffer* ringbuffer)
{
DEBUG_RINGBUFFER("ringbuffer_destroy(%p)", (void*)rb);
if (!rb)
DEBUG_RINGBUFFER("ringbuffer_destroy(%p)", (void*)ringbuffer);
if (!ringbuffer)
return;
free(rb->buffer);
rb->buffer = NULL;
free(ringbuffer->buffer);
ringbuffer->buffer = NULL;
}
static BOOL ringbuffer_realloc(RingBuffer* rb, size_t targetSize)
static BOOL ringbuffer_realloc(RingBuffer* ringbuffer, size_t targetSize)
{
WINPR_ASSERT(rb);
WINPR_ASSERT(ringbuffer);
BYTE* newData = NULL;
DEBUG_RINGBUFFER("ringbuffer_realloc(%p): targetSize: %" PRIdz "", (void*)rb, targetSize);
if (rb->writePtr == rb->readPtr)
if (ringbuffer->writePtr == ringbuffer->readPtr)
{
/* when no size is used we can realloc() and set the heads at the
* beginning of the buffer
*/
newData = (BYTE*)realloc(rb->buffer, targetSize);
newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
if (!newData)
return FALSE;
rb->readPtr = rb->writePtr = 0;
rb->buffer = newData;
ringbuffer->readPtr = ringbuffer->writePtr = 0;
ringbuffer->buffer = newData;
}
else if ((rb->writePtr >= rb->readPtr) && (rb->writePtr < targetSize))
else if ((ringbuffer->writePtr >= ringbuffer->readPtr) && (ringbuffer->writePtr < targetSize))
{
/* we reallocate only if we're in that case, realloc don't touch read
* and write heads
@@ -104,12 +104,12 @@ static BOOL ringbuffer_realloc(RingBuffer* rb, size_t targetSize)
* v v
* [............|XXXXXXXXXXXXXX|..........]
*/
newData = (BYTE*)realloc(rb->buffer, targetSize);
newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
if (!newData)
return FALSE;
rb->buffer = newData;
ringbuffer->buffer = newData;
}
else
{
@@ -121,14 +121,14 @@ static BOOL ringbuffer_realloc(RingBuffer* rb, size_t targetSize)
if (!newData)
return FALSE;
if (rb->readPtr < rb->writePtr)
if (ringbuffer->readPtr < ringbuffer->writePtr)
{
/* readPtr writePtr
* | |
* v v
* [............|XXXXXXXXXXXXXX|..........]
*/
memcpy(newData, rb->buffer + rb->readPtr, ringbuffer_used(rb));
memcpy(newData, ringbuffer->buffer + ringbuffer->readPtr, ringbuffer_used(ringbuffer));
}
else
{
@@ -138,42 +138,43 @@ static BOOL ringbuffer_realloc(RingBuffer* rb, size_t targetSize)
* [XXXXXXXXXXXX|..............|XXXXXXXXXX]
*/
BYTE* dst = newData;
memcpy(dst, rb->buffer + rb->readPtr, rb->size - rb->readPtr);
dst += (rb->size - rb->readPtr);
memcpy(dst, ringbuffer->buffer + ringbuffer->readPtr,
ringbuffer->size - ringbuffer->readPtr);
dst += (ringbuffer->size - ringbuffer->readPtr);
if (rb->writePtr)
memcpy(dst, rb->buffer, rb->writePtr);
if (ringbuffer->writePtr)
memcpy(dst, ringbuffer->buffer, ringbuffer->writePtr);
}
rb->writePtr = rb->size - rb->freeSize;
rb->readPtr = 0;
free(rb->buffer);
rb->buffer = newData;
ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
ringbuffer->readPtr = 0;
free(ringbuffer->buffer);
ringbuffer->buffer = newData;
}
rb->freeSize += (targetSize - rb->size);
rb->size = targetSize;
ringbuffer->freeSize += (targetSize - ringbuffer->size);
ringbuffer->size = targetSize;
return TRUE;
}
/**
* Write to a ringbuffer
*
* @param rb A pointer to the ringbuffer
* @param ringbuffer A pointer to the ringbuffer
* @param ptr A pointer to the data to write
* @param sz The number of bytes to write
*
* @return \b TRUE for success, \b FALSE for failure
*/
BOOL ringbuffer_write(RingBuffer* rb, const BYTE* ptr, size_t sz)
BOOL ringbuffer_write(RingBuffer* ringbuffer, const BYTE* ptr, size_t sz)
{
size_t toWrite = 0;
size_t remaining = 0;
WINPR_ASSERT(rb);
WINPR_ASSERT(ringbuffer);
DEBUG_RINGBUFFER("ringbuffer_write(%p): sz: %" PRIdz "", (void*)rb, sz);
if ((rb->freeSize <= sz) && !ringbuffer_realloc(rb, rb->size + sz))
if ((ringbuffer->freeSize <= sz) && !ringbuffer_realloc(ringbuffer, ringbuffer->size + sz))
return FALSE;
/* the write could be split in two
@@ -185,42 +186,42 @@ BOOL ringbuffer_write(RingBuffer* rb, const BYTE* ptr, size_t sz)
toWrite = sz;
remaining = sz;
if (rb->size - rb->writePtr < sz)
toWrite = rb->size - rb->writePtr;
if (ringbuffer->size - ringbuffer->writePtr < sz)
toWrite = ringbuffer->size - ringbuffer->writePtr;
if (toWrite)
{
memcpy(rb->buffer + rb->writePtr, ptr, toWrite);
memcpy(ringbuffer->buffer + ringbuffer->writePtr, ptr, toWrite);
remaining -= toWrite;
ptr += toWrite;
}
if (remaining)
memcpy(rb->buffer, ptr, remaining);
memcpy(ringbuffer->buffer, ptr, remaining);
rb->writePtr = (rb->writePtr + sz) % rb->size;
rb->freeSize -= sz;
ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
ringbuffer->freeSize -= sz;
return TRUE;
}
BYTE* ringbuffer_ensure_linear_write(RingBuffer* rb, size_t sz)
BYTE* ringbuffer_ensure_linear_write(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_ensure_linear_write(%p): sz: %" PRIdz "", (void*)rb, sz);
WINPR_ASSERT(rb);
if (rb->freeSize < sz)
WINPR_ASSERT(ringbuffer);
if (ringbuffer->freeSize < sz)
{
if (!ringbuffer_realloc(rb, rb->size + sz - rb->freeSize + 32))
if (!ringbuffer_realloc(ringbuffer, ringbuffer->size + sz - ringbuffer->freeSize + 32))
return NULL;
}
if (rb->writePtr == rb->readPtr)
if (ringbuffer->writePtr == ringbuffer->readPtr)
{
rb->writePtr = rb->readPtr = 0;
ringbuffer->writePtr = ringbuffer->readPtr = 0;
}
if (rb->writePtr + sz < rb->size)
return rb->buffer + rb->writePtr;
if (ringbuffer->writePtr + sz < ringbuffer->size)
return ringbuffer->buffer + ringbuffer->writePtr;
/*
* to add: .......
@@ -229,29 +230,30 @@ BYTE* ringbuffer_ensure_linear_write(RingBuffer* rb, size_t sz)
* result:
* [XXXXXXXXX....... ]
*/
memmove(rb->buffer, rb->buffer + rb->readPtr, rb->writePtr - rb->readPtr);
rb->readPtr = 0;
rb->writePtr = rb->size - rb->freeSize;
return rb->buffer + rb->writePtr;
memmove(ringbuffer->buffer, ringbuffer->buffer + ringbuffer->readPtr,
ringbuffer->writePtr - ringbuffer->readPtr);
ringbuffer->readPtr = 0;
ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
return ringbuffer->buffer + ringbuffer->writePtr;
}
BOOL ringbuffer_commit_written_bytes(RingBuffer* rb, size_t sz)
BOOL ringbuffer_commit_written_bytes(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_commit_written_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
WINPR_ASSERT(rb);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return TRUE;
if (rb->writePtr + sz > rb->size)
if (ringbuffer->writePtr + sz > ringbuffer->size)
return FALSE;
rb->writePtr = (rb->writePtr + sz) % rb->size;
rb->freeSize -= sz;
ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
ringbuffer->freeSize -= sz;
return TRUE;
}
int ringbuffer_peek(const RingBuffer* rb, DataChunk chunks[2], size_t sz)
int ringbuffer_peek(const RingBuffer* ringbuffer, DataChunk chunks[2], size_t sz)
{
size_t remaining = sz;
size_t toRead = 0;
@@ -259,21 +261,21 @@ int ringbuffer_peek(const RingBuffer* rb, DataChunk chunks[2], size_t sz)
int status = 0;
DEBUG_RINGBUFFER("ringbuffer_peek(%p): sz: %" PRIdz "", (const void*)rb, sz);
WINPR_ASSERT(rb);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return 0;
if ((rb->size - rb->freeSize) < sz)
remaining = rb->size - rb->freeSize;
if ((ringbuffer->size - ringbuffer->freeSize) < sz)
remaining = ringbuffer->size - ringbuffer->freeSize;
toRead = remaining;
if ((rb->readPtr + remaining) > rb->size)
toRead = rb->size - rb->readPtr;
if ((ringbuffer->readPtr + remaining) > ringbuffer->size)
toRead = ringbuffer->size - ringbuffer->readPtr;
if (toRead)
{
chunks[0].data = rb->buffer + rb->readPtr;
chunks[0].data = ringbuffer->buffer + ringbuffer->readPtr;
chunks[0].size = toRead;
remaining -= toRead;
chunkIndex++;
@@ -282,7 +284,7 @@ int ringbuffer_peek(const RingBuffer* rb, DataChunk chunks[2], size_t sz)
if (remaining)
{
chunks[chunkIndex].data = rb->buffer;
chunks[chunkIndex].data = ringbuffer->buffer;
chunks[chunkIndex].size = remaining;
status++;
}
@@ -290,19 +292,20 @@ int ringbuffer_peek(const RingBuffer* rb, DataChunk chunks[2], size_t sz)
return status;
}
void ringbuffer_commit_read_bytes(RingBuffer* rb, size_t sz)
void ringbuffer_commit_read_bytes(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_commit_read_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
DEBUG_RINGBUFFER("ringbuffer_commit_read_bytes(%p): sz: %" PRIdz "", (void*)ringbuffer, sz);
WINPR_ASSERT(rb);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return;
WINPR_ASSERT(rb->size - rb->freeSize >= sz);
rb->readPtr = (rb->readPtr + sz) % rb->size;
rb->freeSize += sz;
WINPR_ASSERT(ringbuffer->size - ringbuffer->freeSize >= sz);
ringbuffer->readPtr = (ringbuffer->readPtr + sz) % ringbuffer->size;
ringbuffer->freeSize += sz;
/* when we reach a reasonable free size, we can go back to the original size */
if ((rb->size != rb->initialSize) && (ringbuffer_used(rb) < rb->initialSize / 2))
ringbuffer_realloc(rb, rb->initialSize);
if ((ringbuffer->size != ringbuffer->initialSize) &&
(ringbuffer_used(ringbuffer) < ringbuffer->initialSize / 2))
ringbuffer_realloc(ringbuffer, ringbuffer->initialSize);
}

108
libfreerdp/utils/smartcard_call.c
View File

@@ -1585,14 +1585,14 @@ static LONG smartcard_LocateCardsByATRA_Call(scard_call_context* smartcard, wStr
return ret.ReturnCode;
}
LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* out,
NTSTATUS* pIoStatus, SMARTCARD_OPERATION* operation)
LONG smartcard_irp_device_control_call(scard_call_context* ctx, wStream* out, NTSTATUS* pIoStatus,
SMARTCARD_OPERATION* operation)
{
LONG result = 0;
UINT32 offset = 0;
size_t objectBufferLength = 0;
WINPR_ASSERT(smartcard);
WINPR_ASSERT(ctx);
WINPR_ASSERT(out);
WINPR_ASSERT(pIoStatus);
WINPR_ASSERT(operation);
@@ -1619,195 +1619,195 @@ LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* o
switch (ioControlCode)
{
case SCARD_IOCTL_ESTABLISHCONTEXT:
result = smartcard_EstablishContext_Call(smartcard, out, operation);
result = smartcard_EstablishContext_Call(ctx, out, operation);
break;
case SCARD_IOCTL_RELEASECONTEXT:
result = smartcard_ReleaseContext_Call(smartcard, out, operation);
result = smartcard_ReleaseContext_Call(ctx, out, operation);
break;
case SCARD_IOCTL_ISVALIDCONTEXT:
result = smartcard_IsValidContext_Call(smartcard, out, operation);
result = smartcard_IsValidContext_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LISTREADERGROUPSA:
result = smartcard_ListReaderGroupsA_Call(smartcard, out, operation);
result = smartcard_ListReaderGroupsA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LISTREADERGROUPSW:
result = smartcard_ListReaderGroupsW_Call(smartcard, out, operation);
result = smartcard_ListReaderGroupsW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LISTREADERSA:
result = smartcard_ListReadersA_Call(smartcard, out, operation);
result = smartcard_ListReadersA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LISTREADERSW:
result = smartcard_ListReadersW_Call(smartcard, out, operation);
result = smartcard_ListReadersW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_INTRODUCEREADERGROUPA:
result = smartcard_IntroduceReaderGroupA_Call(smartcard, out, operation);
result = smartcard_IntroduceReaderGroupA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_INTRODUCEREADERGROUPW:
result = smartcard_IntroduceReaderGroupW_Call(smartcard, out, operation);
result = smartcard_IntroduceReaderGroupW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_FORGETREADERGROUPA:
result = smartcard_ForgetReaderA_Call(smartcard, out, operation);
result = smartcard_ForgetReaderA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_FORGETREADERGROUPW:
result = smartcard_ForgetReaderW_Call(smartcard, out, operation);
result = smartcard_ForgetReaderW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_INTRODUCEREADERA:
result = smartcard_IntroduceReaderA_Call(smartcard, out, operation);
result = smartcard_IntroduceReaderA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_INTRODUCEREADERW:
result = smartcard_IntroduceReaderW_Call(smartcard, out, operation);
result = smartcard_IntroduceReaderW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_FORGETREADERA:
result = smartcard_ForgetReaderA_Call(smartcard, out, operation);
result = smartcard_ForgetReaderA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_FORGETREADERW:
result = smartcard_ForgetReaderW_Call(smartcard, out, operation);
result = smartcard_ForgetReaderW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_ADDREADERTOGROUPA:
result = smartcard_AddReaderToGroupA_Call(smartcard, out, operation);
result = smartcard_AddReaderToGroupA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_ADDREADERTOGROUPW:
result = smartcard_AddReaderToGroupW_Call(smartcard, out, operation);
result = smartcard_AddReaderToGroupW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
result = smartcard_RemoveReaderFromGroupA_Call(smartcard, out, operation);
result = smartcard_RemoveReaderFromGroupA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
result = smartcard_RemoveReaderFromGroupW_Call(smartcard, out, operation);
result = smartcard_RemoveReaderFromGroupW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LOCATECARDSA:
result = smartcard_LocateCardsA_Call(smartcard, out, operation);
result = smartcard_LocateCardsA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LOCATECARDSW:
result = smartcard_LocateCardsW_Call(smartcard, out, operation);
result = smartcard_LocateCardsW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETSTATUSCHANGEA:
result = smartcard_GetStatusChangeA_Call(smartcard, out, operation);
result = smartcard_GetStatusChangeA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETSTATUSCHANGEW:
result = smartcard_GetStatusChangeW_Call(smartcard, out, operation);
result = smartcard_GetStatusChangeW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_CANCEL:
result = smartcard_Cancel_Call(smartcard, out, operation);
result = smartcard_Cancel_Call(ctx, out, operation);
break;
case SCARD_IOCTL_CONNECTA:
result = smartcard_ConnectA_Call(smartcard, out, operation);
result = smartcard_ConnectA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_CONNECTW:
result = smartcard_ConnectW_Call(smartcard, out, operation);
result = smartcard_ConnectW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_RECONNECT:
result = smartcard_Reconnect_Call(smartcard, out, operation);
result = smartcard_Reconnect_Call(ctx, out, operation);
break;
case SCARD_IOCTL_DISCONNECT:
result = smartcard_Disconnect_Call(smartcard, out, operation);
result = smartcard_Disconnect_Call(ctx, out, operation);
break;
case SCARD_IOCTL_BEGINTRANSACTION:
result = smartcard_BeginTransaction_Call(smartcard, out, operation);
result = smartcard_BeginTransaction_Call(ctx, out, operation);
break;
case SCARD_IOCTL_ENDTRANSACTION:
result = smartcard_EndTransaction_Call(smartcard, out, operation);
result = smartcard_EndTransaction_Call(ctx, out, operation);
break;
case SCARD_IOCTL_STATE:
result = smartcard_State_Call(smartcard, out, operation);
result = smartcard_State_Call(ctx, out, operation);
break;
case SCARD_IOCTL_STATUSA:
result = smartcard_StatusA_Call(smartcard, out, operation);
result = smartcard_StatusA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_STATUSW:
result = smartcard_StatusW_Call(smartcard, out, operation);
result = smartcard_StatusW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_TRANSMIT:
result = smartcard_Transmit_Call(smartcard, out, operation);
result = smartcard_Transmit_Call(ctx, out, operation);
break;
case SCARD_IOCTL_CONTROL:
result = smartcard_Control_Call(smartcard, out, operation);
result = smartcard_Control_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETATTRIB:
result = smartcard_GetAttrib_Call(smartcard, out, operation);
result = smartcard_GetAttrib_Call(ctx, out, operation);
break;
case SCARD_IOCTL_SETATTRIB:
result = smartcard_SetAttrib_Call(smartcard, out, operation);
result = smartcard_SetAttrib_Call(ctx, out, operation);
break;
case SCARD_IOCTL_ACCESSSTARTEDEVENT:
result = smartcard_AccessStartedEvent_Call(smartcard, out, operation);
result = smartcard_AccessStartedEvent_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LOCATECARDSBYATRA:
result = smartcard_LocateCardsByATRA_Call(smartcard, out, operation);
result = smartcard_LocateCardsByATRA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_LOCATECARDSBYATRW:
result = smartcard_LocateCardsW_Call(smartcard, out, operation);
result = smartcard_LocateCardsW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_READCACHEA:
result = smartcard_ReadCacheA_Call(smartcard, out, operation);
result = smartcard_ReadCacheA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_READCACHEW:
result = smartcard_ReadCacheW_Call(smartcard, out, operation);
result = smartcard_ReadCacheW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_WRITECACHEA:
result = smartcard_WriteCacheA_Call(smartcard, out, operation);
result = smartcard_WriteCacheA_Call(ctx, out, operation);
break;
case SCARD_IOCTL_WRITECACHEW:
result = smartcard_WriteCacheW_Call(smartcard, out, operation);
result = smartcard_WriteCacheW_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETTRANSMITCOUNT:
result = smartcard_GetTransmitCount_Call(smartcard, out, operation);
result = smartcard_GetTransmitCount_Call(ctx, out, operation);
break;
case SCARD_IOCTL_RELEASETARTEDEVENT:
result = smartcard_ReleaseStartedEvent_Call(smartcard, out, operation);
result = smartcard_ReleaseStartedEvent_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETREADERICON:
result = smartcard_GetReaderIcon_Call(smartcard, out, operation);
result = smartcard_GetReaderIcon_Call(ctx, out, operation);
break;
case SCARD_IOCTL_GETDEVICETYPEID:
result = smartcard_GetDeviceTypeId_Call(smartcard, out, operation);
result = smartcard_GetDeviceTypeId_Call(ctx, out, operation);
break;
default:
@@ -1834,7 +1834,7 @@ LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* o
(result != SCARD_E_NO_READERS_AVAILABLE) && (result != SCARD_E_NO_SERVICE) &&
(result != SCARD_W_CACHE_ITEM_NOT_FOUND) && (result != SCARD_W_CACHE_ITEM_STALE))
{
WLog_Print(smartcard->log, WLOG_WARN,
WLog_Print(ctx->log, WLOG_WARN,
"IRP failure: %s (0x%08" PRIX32 "), status: %s (0x%08" PRIX32 ")",
scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode,
SCardGetErrorString(result), WINPR_CXX_COMPAT_CAST(UINT32, result));
@@ -1846,7 +1846,7 @@ LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* o
{
/* NTSTATUS error */
*pIoStatus = result;
WLog_Print(smartcard->log, WLOG_WARN,
WLog_Print(ctx->log, WLOG_WARN,
"IRP failure: %s (0x%08" PRIX32 "), ntstatus: 0x%08" PRIX32 "",
scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode,
WINPR_CXX_COMPAT_CAST(UINT32, result));
@@ -1871,7 +1871,7 @@ LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* o
*/
if (outputBufferLength > operation->outputBufferLength)
{
WLog_Print(smartcard->log, WLOG_WARN,
WLog_Print(ctx->log, WLOG_WARN,
"IRP warn: expected outputBufferLength %" PRIu32 ", but current limit %" PRIuz
", respond with STATUS_BUFFER_TOO_SMALL",
operation->outputBufferLength, outputBufferLength);

10
libfreerdp/utils/smartcard_pack.c
View File

@@ -3968,12 +3968,12 @@ LONG smartcard_pack_get_reader_icon_return(wStream* s, const GetReaderIcon_Retur
return ret->ReturnCode;
}
LONG smartcard_pack_get_transmit_count_return(wStream* s, const GetTransmitCount_Return* ret)
LONG smartcard_pack_get_transmit_count_return(wStream* s, const GetTransmitCount_Return* call)
{
WINPR_ASSERT(ret);
WINPR_ASSERT(call);
wLog* log = scard_log();
smartcard_trace_get_transmit_count_return(log, ret);
smartcard_trace_get_transmit_count_return(log, call);
if (!Stream_EnsureRemainingCapacity(s, 4))
{
@@ -3981,9 +3981,9 @@ LONG smartcard_pack_get_transmit_count_return(wStream* s, const GetTransmitCount
return SCARD_F_INTERNAL_ERROR;
}
Stream_Write_UINT32(s, ret->cTransmitCount); /* cBytes (4 cbDataLen) */
Stream_Write_UINT32(s, call->cTransmitCount); /* cBytes (4 cbDataLen) */
return ret->ReturnCode;
return call->ReturnCode;
}
LONG smartcard_pack_read_cache_return(wStream* s, const ReadCache_Return* ret)