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

Merge pull request #11327 from akallabeth/tsg-simplify

Browse Source 
[core,gateway] unify TSG_PACKET_MSG_RESPONSE
This commit is contained in:
akallabeth
2025-03-12 13:46:05 +01:00
committed by GitHub
parent 5d5671aaaa 8fb49b0abe
commit 34576a658d
26 changed files with 235 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.clang-tidy
View File

@@ -28,6 +28,7 @@ Checks: >
-cert-dcl16-c,
-cert-env33-c,
-cert-dcl50-cpp,
-clang-analyzer-webkit.NoUncountedMemberChecker,
-clang-analyzer-optin.performance.Padding,
-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
-clang-analyzer-valist.Uninitialized,

3
channels/cliprdr/cliprdr_common.c
View File

@@ -426,6 +426,9 @@ UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL
while (Stream_GetRemainingLength(sub1) >= 4)
{
if (index >= formatList->numFormats)
goto error_out;
CLIPRDR_FORMAT* format = &formats[index];
Stream_Read_UINT32(sub1, format->formatId); /* formatId (4 bytes) */

2
client/Mac/main.m
View File

@@ -21,5 +21,5 @@
int main(int argc, char *argv[])
{
return NSApplicationMain(argc, argv);
return NSApplicationMain(argc, (const char *const *)argv);
}

2
client/Windows/wf_client.c
View File

@@ -718,7 +718,7 @@ static DWORD wf_is_x509_certificate_trusted(const char* common_name, const char*
CERT_CHAIN_POLICY_STATUS PolicyStatus = { 0 };
CERT_CHAIN_ENGINE_CONFIG EngineConfig = { 0 };
DWORD derPubKeyLen = strlen(fingerprint);
DWORD derPubKeyLen = WINPR_ASSERTING_INT_CAST(uint32_t, strlen(fingerprint));
char* derPubKey = calloc(derPubKeyLen, sizeof(char));
if (NULL == derPubKey)
{

2
client/Windows/wf_cliprdr.c
View File

@@ -2114,7 +2114,7 @@ exit:
if (groupDsc)
{
groupDsc->cItems = clipboard->nFiles;
groupDsc->cItems = WINPR_ASSERTING_INT_CAST(UINT, clipboard->nFiles);
for (size_t i = 0; i < clipboard->nFiles; i++)
{

5
client/common/test/TestClientCmdLine.c
View File

@@ -232,13 +232,14 @@ int TestClientCmdLine(int argc, char* argv[])
WINPR_UNUSED(argc);
WINPR_UNUSED(argv);
for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
for (size_t i = 0; i < ARRAYSIZE(tests); i++)
{
const test* current = &tests[i];
int failure = 0;
char** command_line = string_list_copy(current->command_line);
if (!testcase(__func__, command_line, string_list_length((const char* const*)command_line),
const int len = string_list_length((const char* const*)command_line);
if (!testcase(__func__, command_line, WINPR_ASSERTING_INT_CAST(size_t, len),
current->expected_status, current->validate_settings))
{
TEST_FAILURE("parsing arguments.\n");

2
libfreerdp/codec/test/TestFreeRDPCodecProgressive.c
View File

@@ -1386,7 +1386,7 @@ static int test_dump(int argc, char* argv[])
const RECTANGLE_16* rects = region16_rects(&invalid, &nbRects);
for (size_t x = 0; x < nbRects; x++)
{
RECTANGLE_16* rect = &rects[x];
const RECTANGLE_16* rect = &rects[x];
const UINT32 w = rect->right - rect->left;
const UINT32 h = rect->bottom - rect->top;
if (!freerdp_image_copy_no_overlap(output, DstFormat, stride, rect->left,

8
libfreerdp/codec/test/cursor/cursor_dump_00000000.c
View File

@@ -5,11 +5,11 @@
#include "cursor_dump_00000000.h"
static const uint8_t andmask[] = { 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x80, 0xe3, 0x80, 0xe3,
0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80,
0xe3, 0x80, 0xc1, 0x80, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00 };
static uint8_t andmask[] = { 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x80, 0xe3, 0x80, 0xe3,
0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80, 0xe3, 0x80,
0xe3, 0x80, 0xc1, 0x80, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00 };
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/codec/test/cursor/cursor_dump_00000001.c
View File

@@ -5,7 +5,7 @@
#include "cursor_dump_00000001.h"
static const uint8_t andmask[] = {
static uint8_t andmask[] = {
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xe1, 0xff, 0x00, 0xff, 0xc0, 0xff, 0x00,
0xff, 0xc0, 0xff, 0x00, 0xff, 0xc0, 0xff, 0x00, 0xff, 0xc0, 0xff, 0x00, 0xff, 0xc0, 0xff, 0x00,
0xff, 0xc0, 0xff, 0x00, 0xff, 0xc0, 0xff, 0x00, 0xfc, 0x00, 0x07, 0x00, 0xf8, 0x00, 0x07, 0x00,
@@ -14,7 +14,7 @@ static const uint8_t andmask[] = {
0xf0, 0x00, 0x07, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00
};
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/codec/test/cursor/cursor_dump_00000002.c
View File

@@ -5,7 +5,7 @@
#include "cursor_dump_00000002.h"
static const uint8_t andmask[] = {
static uint8_t andmask[] = {
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x8f, 0xff, 0x00, 0xef, 0x87, 0xff, 0x00,
0xe3, 0x07, 0xff, 0x00, 0xe0, 0x07, 0xff, 0x00, 0xe0, 0x0f, 0xff, 0x00, 0xe0, 0x0f, 0xff, 0x00,
0xe0, 0x01, 0xff, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xe0, 0x01, 0xff, 0x00, 0xe0, 0x03, 0xff, 0x00,
@@ -14,7 +14,7 @@ static const uint8_t andmask[] = {
0xe7, 0xff, 0xff, 0x00, 0xef, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00
};
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/codec/test/cursor/cursor_dump_00000003.c
View File

@@ -5,7 +5,7 @@
#include "cursor_dump_00000003.h"
static const uint8_t andmask[] = {
static uint8_t andmask[] = {
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xc7, 0xff, 0x00,
0xff, 0x83, 0xff, 0x00, 0xff, 0x01, 0xff, 0x00, 0xfe, 0x00, 0xff, 0x00, 0xfc, 0x00, 0x7f, 0x00,
0xf8, 0x00, 0x3f, 0x00, 0xf0, 0xc2, 0x1f, 0x00, 0xe0, 0x82, 0x0f, 0x00, 0xc0, 0x00, 0x07, 0x00,
@@ -14,7 +14,7 @@ static const uint8_t andmask[] = {
0xff, 0x03, 0xff, 0x00, 0xff, 0x87, 0xff, 0x00, 0xff, 0xcf, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00
};
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/codec/test/cursor/cursor_dump_00000004.c
View File

@@ -5,7 +5,7 @@
#include "cursor_dump_00000004.h"
static const uint8_t andmask[] = {
static uint8_t andmask[] = {
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xc7, 0xff, 0x00,
0xff, 0x83, 0xff, 0x00, 0xff, 0x01, 0xff, 0x00, 0xfe, 0x00, 0xff, 0x00, 0xfc, 0x00, 0x7f, 0x00,
0xf8, 0x00, 0x3f, 0x00, 0xf0, 0xc2, 0x1f, 0x00, 0xe0, 0x82, 0x0f, 0x00, 0xc0, 0x00, 0x07, 0x00,
@@ -14,7 +14,7 @@ static const uint8_t andmask[] = {
0xff, 0x03, 0xff, 0x00, 0xff, 0x87, 0xff, 0x00, 0xff, 0xcf, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00
};
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/codec/test/cursor/cursor_dump_00000005.c
View File

@@ -5,7 +5,7 @@
#include "cursor_dump_00000005.h"
static const uint8_t andmask[] = {
static uint8_t andmask[] = {
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x8f, 0xff, 0x00, 0xef, 0x87, 0xff, 0x00,
0xe3, 0x07, 0xff, 0x00, 0xe0, 0x07, 0xff, 0x00, 0xe0, 0x0f, 0xff, 0x00, 0xe0, 0x0f, 0xff, 0x00,
0xe0, 0x01, 0xff, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xe0, 0x01, 0xff, 0x00, 0xe0, 0x03, 0xff, 0x00,
@@ -14,7 +14,7 @@ static const uint8_t andmask[] = {
0xe7, 0xff, 0xff, 0x00, 0xef, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00
};
static const uint8_t xormask[] = {
static uint8_t xormask[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
libfreerdp/core/capabilities.c
View File

@@ -2895,10 +2895,10 @@ static bool sUuidEqual(const UUID* Uuid1, const UUID* Uuid2)
if (!Uuid1 && !Uuid2)
return false;
if (!Uuid2 && Uuid1)
if (Uuid1 && !Uuid2)
return false;
if (!Uuid1 && !Uuid2)
if (!Uuid1 && Uuid2)
return true;
if (Uuid1->Data1 != Uuid2->Data1)

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

@@ -482,10 +482,18 @@ SSIZE_T rpc_channel_read(RpcChannel* channel, wStream* s, size_t length)
return -1;
}
SSIZE_T rpc_channel_write(RpcChannel* channel, const BYTE* data, size_t length)
SSIZE_T rpc_channel_write_int(RpcChannel* channel, const BYTE* data, size_t length,
const char* file, size_t line, const char* fkt)
{
if (!channel)
return -1;
WINPR_ASSERT(channel);
WINPR_ASSERT(channel->rpc);
const DWORD level = WLOG_TRACE;
if (WLog_IsLevelActive(channel->rpc->log, level))
{
WLog_PrintMessage(channel->rpc->log, WLOG_MESSAGE_TEXT, level, line, file, fkt,
"Sending [%s] %" PRIuz " bytes", fkt, length);
}
return freerdp_tls_write_all(channel->tls, data, length);
}

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

@@ -767,7 +767,10 @@ FREERDP_LOCAL size_t rpc_offset_pad(size_t* offset, size_t pad);
FREERDP_LOCAL BOOL rpc_get_stub_data_info(rdpRpc* rpc, const rpcconn_hdr_t* header, size_t* offset,
size_t* length);
FREERDP_LOCAL SSIZE_T rpc_channel_write(RpcChannel* channel, const BYTE* data, size_t length);
#define rpc_channel_write(channel, data, length) \
rpc_channel_write_int((channel), (data), (length), __FILE__, __LINE__, __func__)
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);
FREERDP_LOCAL SSIZE_T rpc_channel_read(RpcChannel* channel, wStream* s, size_t length);

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

@@ -195,8 +195,8 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
rdpTsg* tsg = transport_get_tsg(rpc->transport);
WLog_VRB(TAG, "client state %s, vc state %s", rpc_client_state_str(rpc->State),
rpc_vc_state_str(rpc->VirtualConnection->State));
WLog_Print(rpc->log, WLOG_TRACE, "client state %s, vc state %s",
rpc_client_state_str(rpc->State), rpc_vc_state_str(rpc->VirtualConnection->State));
const BOOL rc = rts_match_pdu_signature_ex(&RTS_PDU_PING_SIGNATURE, pdu->s, NULL, &found, TRUE);
rts_print_pdu_signature(rpc->log, WLOG_TRACE, &found);
@@ -216,15 +216,14 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
case VIRTUAL_CONNECTION_STATE_WAIT_A3W:
if (memcmp(&found, &RTS_PDU_CONN_A3_SIGNATURE, sizeof(found)) != 0)
{
wLog* log = WLog_Get(TAG);
WLog_Print(log, WLOG_ERROR, "unexpected RTS PDU: Expected CONN/A3");
rts_print_pdu_signature(log, WLOG_ERROR, &found);
WLog_Print(rpc->log, WLOG_ERROR, "unexpected RTS PDU: Expected CONN/A3");
rts_print_pdu_signature(rpc->log, WLOG_ERROR, &found);
return -1;
}
if (!rts_recv_CONN_A3_pdu(rpc, pdu->s))
{
WLog_ERR(TAG, "rts_recv_CONN_A3_pdu failure");
WLog_Print(rpc->log, WLOG_ERROR, "rts_recv_CONN_A3_pdu failure");
return -1;
}
@@ -236,15 +235,14 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
case VIRTUAL_CONNECTION_STATE_WAIT_C2:
if (memcmp(&found, &RTS_PDU_CONN_C2_SIGNATURE, sizeof(found)) != 0)
{
wLog* log = WLog_Get(TAG);
WLog_Print(log, WLOG_ERROR, "unexpected RTS PDU: Expected CONN/C2");
rts_print_pdu_signature(log, WLOG_ERROR, &found);
WLog_Print(rpc->log, WLOG_ERROR, "unexpected RTS PDU: Expected CONN/C2");
rts_print_pdu_signature(rpc->log, WLOG_ERROR, &found);
return -1;
}
if (!rts_recv_CONN_C2_pdu(rpc, pdu->s))
{
WLog_ERR(TAG, "rts_recv_CONN_C2_pdu failure");
WLog_Print(rpc->log, WLOG_ERROR, "rts_recv_CONN_C2_pdu failure");
return -1;
}
@@ -254,7 +252,7 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
if (rpc_send_bind_pdu(rpc, TRUE) < 0)
{
WLog_ERR(TAG, "rpc_send_bind_pdu failure");
WLog_Print(rpc->log, WLOG_ERROR, "rpc_send_bind_pdu failure");
return -1;
}
@@ -279,16 +277,16 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
{
if (!rpc_recv_bind_ack_pdu(rpc, pdu->s))
{
WLog_ERR(TAG, "rpc_recv_bind_ack_pdu failure");
WLog_Print(rpc->log, WLOG_ERROR, "rpc_recv_bind_ack_pdu failure");
return -1;
}
}
else
{
WLog_ERR(TAG,
"RPC_CLIENT_STATE_WAIT_SECURE_BIND_ACK unexpected pdu type: 0x%08" PRIX32
"",
pdu->Type);
WLog_Print(rpc->log, WLOG_ERROR,
"RPC_CLIENT_STATE_WAIT_SECURE_BIND_ACK unexpected pdu type: 0x%08" PRIX32
"",
pdu->Type);
return -1;
}
@@ -297,14 +295,15 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
case RPC_BIND_STATE_INCOMPLETE:
if (rpc_send_bind_pdu(rpc, FALSE) < 0)
{
WLog_ERR(TAG, "rpc_send_bind_pdu failure");
WLog_Print(rpc->log, WLOG_ERROR, "rpc_send_bind_pdu failure");
return -1;
}
break;
case RPC_BIND_STATE_LAST_LEG:
if (rpc_send_rpc_auth_3_pdu(rpc) < 0)
{
WLog_ERR(TAG, "rpc_secure_bind: error sending rpc_auth_3 pdu!");
WLog_Print(rpc->log, WLOG_ERROR,
"rpc_secure_bind: error sending rpc_auth_3 pdu!");
return -1;
}
/* fallthrough */
@@ -314,7 +313,7 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
if (!tsg_proxy_begin(tsg))
{
WLog_ERR(TAG, "tsg_proxy_begin failure");
WLog_Print(rpc->log, WLOG_ERROR, "tsg_proxy_begin failure");
return -1;
}
break;
@@ -326,7 +325,7 @@ static int rpc_client_recv_pdu_int(rdpRpc* rpc, RPC_PDU* pdu)
}
else
{
WLog_ERR(TAG, "invalid rpc->State: %d", rpc->State);
WLog_Print(rpc->log, WLOG_ERROR, "invalid rpc->State: %d", rpc->State);
}
}
else if (rpc->State >= RPC_CLIENT_STATE_CONTEXT_NEGOTIATED)
@@ -349,7 +348,7 @@ static int rpc_client_recv_pdu(rdpRpc* rpc, RPC_PDU* pdu)
Stream_SetPosition(pdu->s, 0);
const size_t before = Stream_GetRemainingLength(pdu->s);
WLog_VRB(TAG, "RPC PDU parsing %" PRIuz " bytes", before);
WLog_Print(rpc->log, WLOG_TRACE, "RPC PDU parsing %" PRIuz " bytes", before);
const int rc = rpc_client_recv_pdu_int(rpc, pdu);
if (rc < 0)
return rc;
@@ -357,7 +356,8 @@ static int rpc_client_recv_pdu(rdpRpc* rpc, RPC_PDU* pdu)
if (after > 0)
{
/* Just log so we do not fail if we have some unprocessed padding bytes */
WLog_WARN(TAG, "Incompletely parsed RPC PDU (%" PRIuz " bytes remain)", after);
WLog_Print(rpc->log, WLOG_WARN, "Incompletely parsed RPC PDU (%" PRIuz " bytes remain)",
after);
}
return rc;

13
libfreerdp/core/gateway/rts.c
View File

@@ -1509,15 +1509,26 @@ void rts_generate_cookie(BYTE* cookie)
winpr_RAND(cookie, 16);
}
static BOOL rts_send_buffer(RpcChannel* channel, wStream* s, size_t frag_length)
#define rts_send_buffer(channel, s, frag_length) \
rts_send_buffer_int((channel), (s), (frag_length), __FILE__, __LINE__, __func__)
static BOOL rts_send_buffer_int(RpcChannel* channel, wStream* s, size_t frag_length,
const char* file, size_t line, const char* fkt)
{
BOOL status = FALSE;
SSIZE_T rc = 0;
WINPR_ASSERT(channel);
WINPR_ASSERT(channel->rpc);
WINPR_ASSERT(s);
Stream_SealLength(s);
const DWORD level = WLOG_TRACE;
if (WLog_IsLevelActive(channel->rpc->log, level))
{
WLog_PrintMessage(channel->rpc->log, WLOG_MESSAGE_TEXT, level, line, file, fkt,
"Sending [%s] %" PRIuz " bytes", fkt, Stream_Length(s));
}
if (Stream_Length(s) < sizeof(rpcconn_common_hdr_t))
goto fail;
if (Stream_Length(s) != frag_length)

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

@@ -233,6 +233,8 @@ struct rdp_tsg
wLog* log;
};
static BOOL TsProxyReadPacketSTringMessage(wLog* log, wStream* s, uint32_t* index,
TSG_PACKET_STRING_MESSAGE* msg);
static BOOL tsg_stream_align(wLog* log, wStream* s, size_t align);
static const char* tsg_packet_id_to_string(UINT32 packetId)
@@ -525,11 +527,18 @@ static BOOL tsg_ndr_read_tsg_caps(wLog* log, wStream* s, TSG_PACKET_CAPABILITIES
switch (caps->capabilityType)
{
case TSG_CAPABILITY_TYPE_NAP:
if (count < 1)
{
WLog_Print(log, WLOG_ERROR, "Inconsistent data, capabilityType %s count=%" PRIu32,
tsg_packet_id_to_string(capabilityType), count);
return FALSE;
}
return tsg_ndr_read_nap(log, s, &caps->tsgPacket.tsgCapNap);
default:
WLog_Print(log, WLOG_ERROR,
"unknown TSG_PACKET_CAPABILITIES::capabilityType 0x%04" PRIx32,
caps->capabilityType);
"unknown TSG_PACKET_CAPABILITIES::capabilityType 0x%04" PRIx32
" [count=%" PRIu32 "]",
caps->capabilityType, count);
return FALSE;
}
}
@@ -1457,47 +1466,27 @@ fail:
return rc;
}
static BOOL tsg_ndr_read_consent_message(wLog* log, rdpContext* context, wStream* s, UINT32* index)
static BOOL tsg_ndr_read_consent_message(wLog* log, rdpContext* context, wStream* s, UINT32* index,
BOOL isMessagePresent)
{
TSG_PACKET_STRING_MESSAGE packetStringMessage = { 0 };
UINT32 Pointer = 0;
WINPR_ASSERT(context);
WINPR_ASSERT(index);
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 12))
if (!TsProxyReadPacketSTringMessage(log, s, index, &packetStringMessage))
return FALSE;
Stream_Read_INT32(s, packetStringMessage.isDisplayMandatory);
Stream_Read_INT32(s, packetStringMessage.isConsentMandatory);
Stream_Read_UINT32(s, packetStringMessage.msgBytes);
if (!tsg_ndr_pointer_read(log, s, index, &Pointer, FALSE))
return FALSE;
if (Pointer)
if (context->instance && isMessagePresent)
{
if (packetStringMessage.msgBytes > TSG_MESSAGING_MAX_MESSAGE_LENGTH)
{
WLog_Print(log, WLOG_ERROR, "Out of Spec Message Length %" PRIu32 "",
packetStringMessage.msgBytes);
return FALSE;
}
if (!tsg_ndr_read_string(log, s, &packetStringMessage.msgBuffer,
packetStringMessage.msgBytes))
return FALSE;
if (context->instance)
{
return IFCALLRESULT(TRUE, context->instance->PresentGatewayMessage, context->instance,
TSG_ASYNC_MESSAGE_CONSENT_MESSAGE
? GATEWAY_MESSAGE_CONSENT
: TSG_ASYNC_MESSAGE_SERVICE_MESSAGE,
packetStringMessage.isDisplayMandatory != 0,
packetStringMessage.isConsentMandatory != 0,
packetStringMessage.msgBytes, packetStringMessage.msgBuffer);
}
return IFCALLRESULT(TRUE, context->instance->PresentGatewayMessage, context->instance,
TSG_ASYNC_MESSAGE_CONSENT_MESSAGE ? GATEWAY_MESSAGE_CONSENT
: TSG_ASYNC_MESSAGE_SERVICE_MESSAGE,
packetStringMessage.isDisplayMandatory != 0,
packetStringMessage.isConsentMandatory != 0,
packetStringMessage.msgBytes, packetStringMessage.msgBuffer);
}
return TRUE;
}
@@ -1524,19 +1513,80 @@ static BOOL tsg_ndr_read_tunnel_context(wLog* log, wStream* s, CONTEXT_HANDLE* t
return TRUE;
}
static BOOL tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(wLog* log, wStream* s,
TSG_PACKET_MSG_RESPONSE* pkt)
{
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 16))
return FALSE;
Stream_Read_UINT32(s, pkt->msgID); /* MsgId (4 bytes) */
Stream_Read_UINT32(s, pkt->msgType); /* MsgType (4 bytes) */
Stream_Read_INT32(s, pkt->isMsgPresent); /* IsMsgPresent (4 bytes) */
const uint32_t SwitchValue = Stream_Get_UINT32(s); /* SwitchValue (4 bytes) */
if (pkt->msgType != SwitchValue)
{
WLog_ERR(TAG,
"[MS-TSGU] 2.2.9.2.1.9 TSG_PACKET_MSG_RESPONSE MsgType[0x%08" PRIx32
"] != MessageSwitchValue [0x%08" PRIx32 "]",
pkt->msgType, SwitchValue);
return FALSE;
}
return TRUE;
}
static BOOL tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(wLog* log, rdpContext* context, wStream* s,
uint32_t* index, uint32_t MsgPtr,
const TSG_PACKET_MSG_RESPONSE* pkg,
uint64_t* reauthContext)
{
WINPR_ASSERT(pkg);
if (MsgPtr == 0)
{
WLog_Print(log, WLOG_DEBUG,
"Message {0x%08" PRIx32 "} [%s]::isMsgPresent=%" PRIu32 ", MsgPtr=0x%08" PRIx32,
pkg->msgType, tsg_packet_id_to_string(pkg->msgType), pkg->isMsgPresent, MsgPtr);
return TRUE;
}
switch (pkg->msgType)
{
case TSG_ASYNC_MESSAGE_CONSENT_MESSAGE:
case TSG_ASYNC_MESSAGE_SERVICE_MESSAGE:
return tsg_ndr_read_consent_message(log, context, s, index, pkg->isMsgPresent);
case TSG_ASYNC_MESSAGE_REAUTH:
{
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
return FALSE;
WINPR_ASSERT(reauthContext);
const uint64_t val = Stream_Get_UINT64(s); /* TunnelContext (8 bytes) */
if (pkg->isMsgPresent != 0)
*reauthContext = val;
return TRUE;
}
default:
WLog_Print(log, WLOG_ERROR, "Unexpected Message Type: 0x%" PRIx32 "", pkg->msgType);
return FALSE;
}
}
static BOOL tsg_ndr_read_caps_response(wLog* log, rdpContext* context, wStream* s, UINT32* index,
UINT32 PacketPtr, TSG_PACKET_CAPS_RESPONSE* caps,
CONTEXT_HANDLE* tunnelContext, UINT32* tunnelId)
CONTEXT_HANDLE* tunnelContext, UINT32* tunnelId,
uint64_t* reauthContext)
{
UINT32 PacketQuarResponsePtr = 0;
UINT32 MessageSwitchValue = 0;
UINT32 MsgId = 0;
UINT32 MsgType = 0;
UINT32 IsMessagePresent = 0;
WINPR_ASSERT(context);
WINPR_ASSERT(index);
WINPR_ASSERT(caps);
WINPR_ASSERT(reauthContext);
if (!tsg_ndr_pointer_read(log, s, index, &PacketQuarResponsePtr, TRUE))
goto fail;
@@ -1546,61 +1596,21 @@ static BOOL tsg_ndr_read_caps_response(wLog* log, rdpContext* context, wStream*
if (PacketPtr)
{
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 16))
TSG_PACKET_MSG_RESPONSE pkg = { 0 };
UINT32 MsgPtr = 0;
if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(log, s, &pkg))
goto fail;
Stream_Read_UINT32(s, MsgId); /* MsgId (4 bytes) */
Stream_Read_UINT32(s, MsgType); /* MsgType (4 bytes) */
Stream_Read_UINT32(s, IsMessagePresent); /* IsMessagePresent (4 bytes) */
if (IsMessagePresent != 0)
{
if (!tsg_ndr_pointer_read(log, s, index, &MsgPtr, TRUE))
return FALSE;
Stream_Read_UINT32(s, MessageSwitchValue); /* MessageSwitchValue (4 bytes) */
if (!tsg_ndr_read_quarenc_data(log, s, index, &caps->pktQuarEncResponse))
goto fail;
(void)MsgId; /* [MS-TSGU] 2.2.9.2.1.9 TSG_PACKET_MSG_RESPONSE MsgId is unused */
if (MsgType != MessageSwitchValue)
{
WLog_ERR(TAG,
"[MS-TSGU] 2.2.9.2.1.9 TSG_PACKET_MSG_RESPONSE MsgType[0x%08" PRIx32
"] != MessageSwitchValue [0x%08" PRIx32 "]",
MsgType, MessageSwitchValue);
goto fail;
}
{
UINT32 MsgPtr = 0;
if (!tsg_ndr_pointer_read(log, s, index, &MsgPtr, TRUE))
return FALSE;
}
if (!tsg_ndr_read_quarenc_data(log, s, index, &caps->pktQuarEncResponse))
goto fail;
switch (MessageSwitchValue)
{
case TSG_ASYNC_MESSAGE_CONSENT_MESSAGE:
case TSG_ASYNC_MESSAGE_SERVICE_MESSAGE:
if (!tsg_ndr_read_consent_message(log, context, s, index))
goto fail;
break;
case TSG_ASYNC_MESSAGE_REAUTH:
{
if (!tsg_stream_align(log, s, 8))
goto fail;
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
goto fail;
Stream_Seek_UINT64(s); /* TunnelContext (8 bytes) */
}
break;
default:
WLog_Print(log, WLOG_ERROR, "Unexpected Message Type: 0x%" PRIX32 "",
MessageSwitchValue);
goto fail;
}
}
if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(log, context, s, index, MsgPtr, &pkg,
reauthContext))
goto fail;
}
return tsg_ndr_read_tunnel_context(log, s, tunnelContext, tunnelId);
@@ -1643,7 +1653,7 @@ static BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg, const RPC_PDU* pdu,
{
if (!tsg_ndr_read_caps_response(tsg->log, context, pdu->s, &index, PacketPtr,
&packet.tsgPacket.packetCapsResponse, tunnelContext,
tunnelId))
tunnelId, &tsg->ReauthTunnelContext))
goto fail;
}
else if ((packet.packetId == TSG_PACKET_TYPE_QUARENC_RESPONSE) &&
@@ -1674,6 +1684,12 @@ static BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg, const RPC_PDU* pdu,
goto fail;
}
const size_t rem = Stream_GetRemainingLength(pdu->s);
if (rem != 0)
{
WLog_Print(tsg->log, WLOG_WARN, "Partially parsed %s, %" PRIuz " bytes remain",
tsg_packet_id_to_string(packet.packetId), rem);
}
rc = TRUE;
fail:
return rc;
@@ -1880,42 +1896,48 @@ fail:
return FALSE;
}
static BOOL TsProxyReadPacketSTringMessage(rdpTsg* tsg, wStream* s, TSG_PACKET_STRING_MESSAGE* msg)
static BOOL TsProxyReadPacketSTringMessage(wLog* log, wStream* s, uint32_t* index,
TSG_PACKET_STRING_MESSAGE* msg)
{
UINT32 ConsentMessagePtr = 0;
UINT32 MsgPtr = 0;
UINT32 index = 0;
if (!tsg || !s || !msg)
return FALSE;
WINPR_ASSERT(msg);
if (!Stream_CheckAndLogRequiredLengthWLog(tsg->log, s, 32))
return FALSE;
const TSG_PACKET_STRING_MESSAGE empty = { 0 };
*msg = empty;
if (!tsg_ndr_pointer_read(tsg->log, s, &index, &ConsentMessagePtr, TRUE))
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 12))
return FALSE;
Stream_Read_INT32(s, msg->isDisplayMandatory); /* IsDisplayMandatory (4 bytes) */
Stream_Read_INT32(s, msg->isConsentMandatory); /* IsConsentMandatory (4 bytes) */
Stream_Read_UINT32(s, msg->msgBytes); /* MsgBytes (4 bytes) */
if (!tsg_ndr_pointer_read(tsg->log, s, &index, &MsgPtr, TRUE))
if (!tsg_ndr_pointer_read(log, s, index, &MsgPtr, msg->msgBytes != 0))
return FALSE;
return tsg_ndr_read_string(tsg->log, s, &msg->msgBuffer, msg->msgBytes);
if (msg->msgBytes > TSG_MESSAGING_MAX_MESSAGE_LENGTH)
{
WLog_Print(log, WLOG_ERROR, "Out of Spec Message Length %" PRIu32 "", msg->msgBytes);
return FALSE;
}
if (msg->msgBytes == 0)
{
WLog_Print(log, WLOG_DEBUG, "Empty message, skipping string read");
return TRUE;
}
return tsg_ndr_read_string(log, s, &msg->msgBuffer, msg->msgBytes);
}
static BOOL TsProxyMakeTunnelCallReadResponse(rdpTsg* tsg, const RPC_PDU* pdu)
{
BOOL rc = FALSE;
UINT32 index = 0;
UINT32 SwitchValue = 0;
TSG_PACKET packet;
TSG_PACKET packet = { 0 };
rdpContext* context = NULL;
char* messageText = NULL;
TSG_PACKET_MSG_RESPONSE packetMsgResponse = { 0 };
TSG_PACKET_STRING_MESSAGE packetStringMessage = { 0 };
TSG_PACKET_REAUTH_MESSAGE packetReauthMessage = { 0 };
UINT32 PacketPtr = 0;
UINT32 PacketMsgResponsePtr = 0;
@@ -1937,12 +1959,11 @@ static BOOL TsProxyMakeTunnelCallReadResponse(rdpTsg* tsg, const RPC_PDU* pdu)
goto fail;
Stream_Read_UINT32(pdu->s, packet.packetId); /* PacketId (4 bytes) */
Stream_Read_UINT32(pdu->s, SwitchValue); /* SwitchValue (4 bytes) */
const uint32_t SwitchValue = Stream_Get_UINT32(pdu->s); /* SwitchValue (4 bytes) */
WLog_Print(tsg->log, WLOG_DEBUG, "%s", tsg_packet_id_to_string(packet.packetId));
if ((packet.packetId != TSG_PACKET_TYPE_MESSAGE_PACKET) ||
(SwitchValue != TSG_PACKET_TYPE_MESSAGE_PACKET))
if ((packet.packetId != TSG_PACKET_TYPE_MESSAGE_PACKET) || (packet.packetId != SwitchValue))
{
WLog_Print(tsg->log, WLOG_ERROR,
"Unexpected PacketId: 0x%08" PRIX32 ", Expected TSG_PACKET_TYPE_MESSAGE_PACKET",
@@ -1953,84 +1974,16 @@ static BOOL TsProxyMakeTunnelCallReadResponse(rdpTsg* tsg, const RPC_PDU* pdu)
if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &PacketMsgResponsePtr, TRUE))
goto fail;
Stream_Read_UINT32(pdu->s, packetMsgResponse.msgID); /* MsgId (4 bytes) */
Stream_Read_UINT32(pdu->s, packetMsgResponse.msgType); /* MsgType (4 bytes) */
Stream_Read_INT32(pdu->s, packetMsgResponse.isMsgPresent); /* IsMsgPresent (4 bytes) */
/* 2.2.9.2.1.9 TSG_PACKET_MSG_RESPONSE: Ignore empty message body. */
if (!packetMsgResponse.isMsgPresent)
{
rc = TRUE;
if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(tsg->log, pdu->s, &packetMsgResponse))
goto fail;
}
Stream_Read_UINT32(pdu->s, SwitchValue); /* SwitchValue (4 bytes) */
UINT32 MessagePtr = 0;
if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &MessagePtr, TRUE))
goto fail;
switch (SwitchValue)
{
case TSG_ASYNC_MESSAGE_CONSENT_MESSAGE:
if (!TsProxyReadPacketSTringMessage(tsg, pdu->s, &packetStringMessage))
goto fail;
messageText = ConvertWCharNToUtf8Alloc(
packetStringMessage.msgBuffer, packetStringMessage.msgBytes / sizeof(WCHAR), NULL);
WLog_Print(tsg->log, WLOG_INFO, "Consent Message: %s", messageText);
free(messageText);
if (context->instance)
{
rc = IFCALLRESULT(TRUE, context->instance->PresentGatewayMessage, context->instance,
GATEWAY_MESSAGE_CONSENT,
packetStringMessage.isDisplayMandatory != 0,
packetStringMessage.isConsentMandatory != 0,
packetStringMessage.msgBytes, packetStringMessage.msgBuffer);
if (!rc)
goto fail;
}
break;
case TSG_ASYNC_MESSAGE_SERVICE_MESSAGE:
if (!TsProxyReadPacketSTringMessage(tsg, pdu->s, &packetStringMessage))
goto fail;
messageText = ConvertWCharNToUtf8Alloc(
packetStringMessage.msgBuffer, packetStringMessage.msgBytes / sizeof(WCHAR), NULL);
WLog_Print(tsg->log, WLOG_INFO, "Service Message: %s", messageText);
free(messageText);
if (context->instance)
{
rc = IFCALLRESULT(TRUE, context->instance->PresentGatewayMessage, context->instance,
GATEWAY_MESSAGE_SERVICE,
packetStringMessage.isDisplayMandatory != 0,
packetStringMessage.isConsentMandatory != 0,
packetStringMessage.msgBytes, packetStringMessage.msgBuffer);
if (!rc)
goto fail;
}
break;
case TSG_ASYNC_MESSAGE_REAUTH:
{
UINT32 ReauthMessagePtr = 0;
if (!Stream_CheckAndLogRequiredLengthWLog(tsg->log, pdu->s, 20))
goto fail;
if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &ReauthMessagePtr, TRUE))
goto fail;
Stream_Seek_UINT32(pdu->s); /* alignment pad (4 bytes) */
Stream_Read_UINT64(pdu->s,
packetReauthMessage.tunnelContext); /* TunnelContext (8 bytes) */
Stream_Seek_UINT32(pdu->s); /* ReturnValue (4 bytes) */
tsg->ReauthTunnelContext = packetReauthMessage.tunnelContext;
}
break;
default:
WLog_Print(tsg->log, WLOG_ERROR, "unexpected message type: %" PRIu32 "", SwitchValue);
goto fail;
}
if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(tsg->log, context, pdu->s, &index, MessagePtr,
&packetMsgResponse, &tsg->ReauthTunnelContext))
goto fail;
rc = TRUE;
fail:

9
libfreerdp/primitives/sse/prim_templates.h
View File

@@ -139,7 +139,6 @@
int shifts = 0; \
const _type_* sptr = pSrc; \
_type_* dptr = pDst; \
size_t count; \
__m128i xmm0; \
if (sizeof(_type_) == 1) \
shifts = 1; \
@@ -150,10 +149,10 @@
else if (sizeof(_type_) == 8) \
shifts = 4; \
/* Use 4 128-bit SSE registers. */ \
count = len >> (7 - shifts); \
size_t count = len >> (7 - shifts); \
len -= count << (7 - shifts); \
xmm0 = mm_set1_epu32(val); \
while (count--) \
for (size_t x = 0; x < count; x++) \
{ \
__m128i xmm1 = LOAD_SI128(sptr); \
sptr += (16 / sizeof(_type_)); \
@@ -179,7 +178,7 @@
/* Use a single 128-bit SSE register. */ \
count = len >> (5 - shifts); \
len -= count << (5 - shifts); \
while (count--) \
for (size_t x = 0; x < count; x++) \
{ \
__m128i xmm1 = LOAD_SI128(sptr); \
sptr += (16 / sizeof(_type_)); \
@@ -188,7 +187,7 @@
dptr += (16 / sizeof(_type_)); \
} \
/* Finish off the remainder. */ \
while (len--) \
for (size_t x = 0; x < len; x++) \
{ \
_slowWay_; \
} \

12
libfreerdp/primitives/test/TestPrimitivesYUV.c
View File

@@ -1036,9 +1036,11 @@ static BOOL compare_yuv444_to_rgb(prim_size_t roi, DWORD type)
if (!allocate_yuv(yuv, roi) || !rgb1 || !rgb2)
goto fail;
if (soft->YUV444ToRGB_8u_P3AC4R(yuv, yuvStep, rgb1, stride, format, &roi) != PRIMITIVES_SUCCESS)
const BYTE* cyuv[] = { yuv[0], yuv[1], yuv[2] };
if (soft->YUV444ToRGB_8u_P3AC4R(cyuv, yuvStep, rgb1, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
if (prims->YUV444ToRGB_8u_P3AC4R(yuv, yuvStep, rgb2, stride, format, &roi) !=
if (prims->YUV444ToRGB_8u_P3AC4R(cyuv, yuvStep, rgb2, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
@@ -1207,9 +1209,11 @@ static BOOL compare_yuv420_to_rgb(prim_size_t roi, DWORD type)
if (!allocate_yuv(yuv, roi) || !rgb1 || !rgb2)
goto fail;
if (soft->YUV420ToRGB_8u_P3AC4R(yuv, yuvStep, rgb1, stride, format, &roi) != PRIMITIVES_SUCCESS)
const BYTE* cyuv[3] = { yuv[0], yuv[1], yuv[2] };
if (soft->YUV420ToRGB_8u_P3AC4R(cyuv, yuvStep, rgb1, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
if (prims->YUV420ToRGB_8u_P3AC4R(yuv, yuvStep, rgb2, stride, format, &roi) !=
if (prims->YUV420ToRGB_8u_P3AC4R(cyuv, yuvStep, rgb2, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;

6
winpr/include/winpr/strlst.h
View File

@@ -30,9 +30,9 @@ extern "C"
#endif
WINPR_API void string_list_free(char** string_list);
WINPR_API int string_list_length(const char** string_list);
WINPR_API char** string_list_copy(const char** string_list);
WINPR_API void string_list_print(FILE* out, const char** string_list);
WINPR_API int string_list_length(const char* const* string_list);
WINPR_API char** string_list_copy(const char* const* string_list);
WINPR_API void string_list_print(FILE* out, const char* const* string_list);
#ifdef __cplusplus
}

3
winpr/libwinpr/sspi/NTLM/ntlm_av_pairs.c
View File

@@ -554,7 +554,7 @@ fail:
BOOL ntlm_construct_authenticate_target_info(NTLM_CONTEXT* context)
{
ULONG AvPairsCount = 0;
ULONG AvPairsValueLength = 0;
size_t AvPairsValueLength = 0;
NTLM_AV_PAIR* AvTimestamp = NULL;
NTLM_AV_PAIR* AvNbDomainName = NULL;
NTLM_AV_PAIR* AvNbComputerName = NULL;
@@ -575,7 +575,6 @@ BOOL ntlm_construct_authenticate_target_info(NTLM_CONTEXT* context)
WINPR_ASSERT(context);
AvPairsCount = 1;
AvPairsValueLength = 0;
ChallengeTargetInfo = (NTLM_AV_PAIR*)context->ChallengeTargetInfo.pvBuffer;
cbChallengeTargetInfo = context->ChallengeTargetInfo.cbBuffer;
AvNbDomainName = ntlm_av_pair_get(ChallengeTargetInfo, cbChallengeTargetInfo, MsvAvNbDomainName,

4
winpr/libwinpr/utils/collections/BufferPool.c
View File

@@ -379,7 +379,7 @@ BOOL BufferPool_Return(wBufferPool* pool, void* buffer)
if ((pool->size + 1) >= pool->capacity)
{
SSIZE_T newCapacity = MAX(1, pool->size + (pool->size + 2) / 2 + 1);
SSIZE_T newCapacity = MAX(2, pool->size + (pool->size + 2) / 2 + 1);
void** newArray = (void**)realloc(
(void*)pool->array, sizeof(void*) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity));
if (!newArray)
@@ -416,7 +416,7 @@ BOOL BufferPool_Return(wBufferPool* pool, void* buffer)
{
if ((pool->aSize + 1) >= pool->aCapacity)
{
SSIZE_T newCapacity = MAX(1, pool->aSize + (pool->aSize + 2) / 2 + 1);
SSIZE_T newCapacity = MAX(2, pool->aSize + (pool->aSize + 2) / 2 + 1);
wBufferPoolItem* newArray = (wBufferPoolItem*)realloc(
pool->aArray,
sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity));

6
winpr/libwinpr/utils/strlst.c
View File

@@ -35,7 +35,7 @@ void string_list_free(char** string_list)
free((void*)string_list);
}
int string_list_length(const char** string_list)
int string_list_length(const char* const* string_list)
{
int i = 0;
for (; string_list[i]; i++)
@@ -44,7 +44,7 @@ int string_list_length(const char** string_list)
return i;
}
char** string_list_copy(const char** string_list)
char** string_list_copy(const char* const* string_list)
{
int length = string_list_length(string_list);
char** copy = (char**)calloc(WINPR_ASSERTING_INT_CAST(size_t, length) + 1, sizeof(char*));
@@ -63,7 +63,7 @@ char** string_list_copy(const char** string_list)
return copy;
}
void string_list_print(FILE* out, const char** string_list)
void string_list_print(FILE* out, const char* const* string_list)
{
for (int j = 0; string_list[j]; j++)
{

3
winpr/libwinpr/utils/windows/debug.c
View File

@@ -147,7 +147,8 @@ char* winpr_win_strerror(DWORD dw, char* dmsg, size_t size)
if (rc > 0)
{
#if defined(UNICODE)
WideCharToMultiByte(CP_ACP, 0, msg, (int)rc, dmsg, (int)MIN(size - 1, INT_MAX), NULL, NULL);
(void)WideCharToMultiByte(CP_ACP, 0, msg, (int)rc, dmsg, (int)MIN(size - 1, INT_MAX), NULL,
NULL);
#else /* defined(UNICODE) */
memcpy(dmsg, msg, MIN(rc, size - 1));
#endif /* defined(UNICODE) */