mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[warnings] fix some compiler warnings

Browse Source 
* fix compiler warnings found in a lot of places
* add missing enum type for clipboard channel
* mark deallocator for winpr image function
This commit is contained in:
akallabeth 2024-10-30 12:37:36 +01:00
parent d11be9025d
commit dc76879e0b
No known key found for this signature in database
GPG Key ID: A49454A3FC909FD5
23 changed files with 215 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
channels/cliprdr/cliprdr_common.c
View File

@ -32,6 +32,8 @@ static const char* CB_MSG_TYPE_STR(UINT32 type)
{ {
switch (type) switch (type)
{ {
case CB_TYPE_NONE:
return "CB_TYPE_NONE";
case CB_MONITOR_READY: case CB_MONITOR_READY:
return "CB_MONITOR_READY"; return "CB_MONITOR_READY";
case CB_FORMAT_LIST: case CB_FORMAT_LIST:

17
channels/sshagent/client/sshagent_main.c
View File

@ -131,13 +131,13 @@ static int connect_to_sshagent(const char* udspath)
static DWORD WINAPI sshagent_read_thread(LPVOID data) static DWORD WINAPI sshagent_read_thread(LPVOID data)
{ {
SSHAGENT_CHANNEL_CALLBACK* callback = (SSHAGENT_CHANNEL_CALLBACK*)data; SSHAGENT_CHANNEL_CALLBACK* callback = (SSHAGENT_CHANNEL_CALLBACK*)data;
BYTE buffer[4096]; BYTE buffer[4096] = { 0 };
int going = 1; int going = 1;
UINT status = CHANNEL_RC_OK; UINT status = CHANNEL_RC_OK;
while (going) while (going)
{ {
int bytes_read = read(callback->agent_fd, buffer, sizeof(buffer)); const ssize_t bytes_read = read(callback->agent_fd, buffer, sizeof(buffer));
if (bytes_read == 0) if (bytes_read == 0)
{ {
@ -153,11 +153,16 @@ static DWORD WINAPI sshagent_read_thread(LPVOID data)
going = 0; going = 0;
} }
} }
else if ((size_t)bytes_read > ULONG_MAX)
{
status = ERROR_READ_FAULT;
going = 0;
}
else else
{ {
/* Something read: forward to virtual channel */ /* Something read: forward to virtual channel */
IWTSVirtualChannel* channel = callback->generic.channel; IWTSVirtualChannel* channel = callback->generic.channel;
status = channel->Write(channel, bytes_read, buffer, NULL); status = channel->Write(channel, (ULONG)bytes_read, buffer, NULL);
if (status != CHANNEL_RC_OK) if (status != CHANNEL_RC_OK)
{ {
@ -184,15 +189,15 @@ static UINT sshagent_on_data_received(IWTSVirtualChannelCallback* pChannelCallba
{ {
SSHAGENT_CHANNEL_CALLBACK* callback = (SSHAGENT_CHANNEL_CALLBACK*)pChannelCallback; SSHAGENT_CHANNEL_CALLBACK* callback = (SSHAGENT_CHANNEL_CALLBACK*)pChannelCallback;
BYTE* pBuffer = Stream_Pointer(data); BYTE* pBuffer = Stream_Pointer(data);
UINT32 cbSize = Stream_GetRemainingLength(data); size_t cbSize = Stream_GetRemainingLength(data);
BYTE* pos = pBuffer; BYTE* pos = pBuffer;
/* Forward what we have received to the ssh agent */ /* Forward what we have received to the ssh agent */
UINT32 bytes_to_write = cbSize; size_t bytes_to_write = cbSize;
errno = 0; errno = 0;
while (bytes_to_write > 0) while (bytes_to_write > 0)
{ {
int bytes_written = write(callback->agent_fd, pos, bytes_to_write); const ssize_t bytes_written = write(callback->agent_fd, pos, bytes_to_write);
if (bytes_written < 0) if (bytes_written < 0)
{ {

18
channels/tsmf/client/alsa/tsmf_alsa.c
View File

@ -141,10 +141,6 @@ static BOOL tsmf_alsa_set_format(ITSMFAudioDevice* audio, UINT32 sample_rate, UI
static BOOL tsmf_alsa_play(ITSMFAudioDevice* audio, const BYTE* src, UINT32 data_size) static BOOL tsmf_alsa_play(ITSMFAudioDevice* audio, const BYTE* src, UINT32 data_size)
{ {
int len = 0;
int error = 0;
int frames = 0;
const BYTE* end = NULL;
const BYTE* pindex = NULL; const BYTE* pindex = NULL;
TSMFAlsaAudioDevice* alsa = (TSMFAlsaAudioDevice*)audio; TSMFAlsaAudioDevice* alsa = (TSMFAlsaAudioDevice*)audio;
DEBUG_TSMF("data_size %" PRIu32 "", data_size); DEBUG_TSMF("data_size %" PRIu32 "", data_size);
@ -153,22 +149,22 @@ static BOOL tsmf_alsa_play(ITSMFAudioDevice* audio, const BYTE* src, UINT32 data
{ {
const size_t rbytes_per_frame = 1ULL * alsa->actual_channels * alsa->bytes_per_sample; const size_t rbytes_per_frame = 1ULL * alsa->actual_channels * alsa->bytes_per_sample;
pindex = src; pindex = src;
end = pindex + data_size; const BYTE* end = pindex + data_size;
while (pindex < end) while (pindex < end)
{ {
len = end - pindex; const size_t len = (size_t)(end - pindex);
frames = len / rbytes_per_frame; const size_t frames = len / rbytes_per_frame;
error = snd_pcm_writei(alsa->out_handle, pindex, frames); snd_pcm_sframes_t error = snd_pcm_writei(alsa->out_handle, pindex, frames);
if (error == -EPIPE) if (error == -EPIPE)
{ {
snd_pcm_recover(alsa->out_handle, error, 0); snd_pcm_recover(alsa->out_handle, -EPIPE, 0);
error = 0; error = 0;
} }
else if (error < 0) else if (error < 0)
{ {
DEBUG_TSMF("error len %d", error); DEBUG_TSMF("error len %ld", error);
snd_pcm_close(alsa->out_handle); snd_pcm_close(alsa->out_handle);
alsa->out_handle = 0; alsa->out_handle = 0;
tsmf_alsa_open_device(alsa); tsmf_alsa_open_device(alsa);
@ -180,7 +176,7 @@ static BOOL tsmf_alsa_play(ITSMFAudioDevice* audio, const BYTE* src, UINT32 data
if (error == 0) if (error == 0)
break; break;
pindex += error * rbytes_per_frame; pindex += (size_t)error * rbytes_per_frame;
} }
} }

20
channels/tsmf/client/ffmpeg/tsmf_ffmpeg.c
View File

@ -82,7 +82,7 @@ typedef struct
enum AVCodecID codec_id; enum AVCodecID codec_id;
#endif #endif
AVCodecContext* codec_context; AVCodecContext* codec_context;
AVCodec* codec; const AVCodec* codec;
AVFrame* frame; AVFrame* frame;
int prepared; int prepared;
@ -458,10 +458,7 @@ static BOOL tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const BYTE* data, UI
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder; TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
int len = 0; int len = 0;
int frame_size = 0; int frame_size = 0;
UINT32 src_size = 0;
const BYTE* src = NULL;
BYTE* dst = NULL;
int dst_offset = 0;
#if 0 #if 0
WLog_DBG(TAG, ("tsmf_ffmpeg_decode_audio: data_size %"PRIu32"", data_size)); WLog_DBG(TAG, ("tsmf_ffmpeg_decode_audio: data_size %"PRIu32"", data_size));
@ -484,10 +481,10 @@ static BOOL tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const BYTE* data, UI
return FALSE; return FALSE;
/* align the memory for SSE2 needs */ /* align the memory for SSE2 needs */
dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F); BYTE* dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F);
dst_offset = dst - mdecoder->decoded_data; size_t dst_offset = (size_t)(dst - mdecoder->decoded_data);
src = data; const BYTE* src = data;
src_size = data_size; UINT32 src_size = data_size;
while (src_size > 0) while (src_size > 0)
{ {
@ -504,11 +501,12 @@ static BOOL tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const BYTE* data, UI
mdecoder->decoded_data = tmp_data; mdecoder->decoded_data = tmp_data;
dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F); dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F);
if (dst - mdecoder->decoded_data != dst_offset) const size_t diff = (size_t)(dst - mdecoder->decoded_data);
if (diff != dst_offset)
{ {
/* re-align the memory if the alignment has changed after realloc */ /* re-align the memory if the alignment has changed after realloc */
memmove(dst, mdecoder->decoded_data + dst_offset, mdecoder->decoded_size); memmove(dst, mdecoder->decoded_data + dst_offset, mdecoder->decoded_size);
dst_offset = dst - mdecoder->decoded_data; dst_offset = diff;
} }
dst += mdecoder->decoded_size; dst += mdecoder->decoded_size;

3
channels/tsmf/client/oss/tsmf_oss.c
View File

@ -167,7 +167,6 @@ static BOOL tsmf_oss_set_format(ITSMFAudioDevice* audio, UINT32 sample_rate, UIN
static BOOL tsmf_oss_play(ITSMFAudioDevice* audio, const BYTE* data, UINT32 data_size) static BOOL tsmf_oss_play(ITSMFAudioDevice* audio, const BYTE* data, UINT32 data_size)
{ {
int status = 0;
UINT32 offset = 0; UINT32 offset = 0;
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio; TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
DEBUG_TSMF("tsmf_oss_play: data_size %" PRIu32 "", data_size); DEBUG_TSMF("tsmf_oss_play: data_size %" PRIu32 "", data_size);
@ -183,7 +182,7 @@ static BOOL tsmf_oss_play(ITSMFAudioDevice* audio, const BYTE* data, UINT32 data
while (offset < data_size) while (offset < data_size)
{ {
status = write(oss->pcm_handle, &data[offset], (data_size - offset)); const ssize_t status = write(oss->pcm_handle, &data[offset], (data_size - offset));
if (status < 0) if (status < 0)
{ {

8
channels/tsmf/client/tsmf_codec.c
View File

@ -251,6 +251,8 @@ static const TSMFMediaTypeMap tsmf_format_type_map[] = {
static void tsmf_print_guid(const BYTE* guid) static void tsmf_print_guid(const BYTE* guid)
{ {
WINPR_UNUSED(guid);
#ifdef WITH_DEBUG_TSMF #ifdef WITH_DEBUG_TSMF
char guidString[37]; char guidString[37];
@ -321,7 +323,7 @@ static UINT32 tsmf_codec_parse_VIDEOINFOHEADER2(TS_AM_MEDIA_TYPE* mediatype, wSt
/* VIDEOINFOHEADER2.AvgTimePerFrame */ /* VIDEOINFOHEADER2.AvgTimePerFrame */
Stream_Read_UINT64(s, AvgTimePerFrame); Stream_Read_UINT64(s, AvgTimePerFrame);
mediatype->SamplesPerSecond.Numerator = 1000000; mediatype->SamplesPerSecond.Numerator = 1000000;
mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL); mediatype->SamplesPerSecond.Denominator = (UINT32)(AvgTimePerFrame / 10ULL);
/* Remaining fields before bmiHeader */ /* Remaining fields before bmiHeader */
Stream_Seek(s, 24); Stream_Seek(s, 24);
return 72; return 72;
@ -359,7 +361,7 @@ static UINT32 tsmf_codec_parse_VIDEOINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, wStr
/* VIDEOINFOHEADER.AvgTimePerFrame */ /* VIDEOINFOHEADER.AvgTimePerFrame */
Stream_Read_UINT64(s, AvgTimePerFrame); Stream_Read_UINT64(s, AvgTimePerFrame);
mediatype->SamplesPerSecond.Numerator = 1000000; mediatype->SamplesPerSecond.Numerator = 1000000;
mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL); mediatype->SamplesPerSecond.Denominator = (UINT32)(AvgTimePerFrame / 10ULL);
return 48; return 48;
} }
@ -393,7 +395,7 @@ static BOOL tsmf_read_format_type(TS_AM_MEDIA_TYPE* mediatype, wStream* s, UINT3
return FALSE; return FALSE;
if (!Stream_CheckAndLogRequiredLength(TAG, s, nsize)) if (!Stream_CheckAndLogRequiredLength(TAG, s, nsize))
return FALSE; return FALSE;
mediatype->ExtraDataSize = nsize; mediatype->ExtraDataSize = (UINT32)nsize;
mediatype->ExtraData = Stream_Pointer(s); mediatype->ExtraData = Stream_Pointer(s);
} }
break; break;

4
channels/tsmf/client/tsmf_decoder.h
View File

@ -57,8 +57,8 @@ struct s_ITSMFDecoder
UINT64 (*GetRunningTime)(ITSMFDecoder* decoder); UINT64 (*GetRunningTime)(ITSMFDecoder* decoder);
/* Update Gstreamer Rendering Area */ /* Update Gstreamer Rendering Area */
BOOL(*UpdateRenderingArea) BOOL(*UpdateRenderingArea)
(ITSMFDecoder* decoder, int newX, int newY, int newWidth, int newHeight, int numRectangles, (ITSMFDecoder* decoder, UINT32 newX, UINT32 newY, UINT32 newWidth, UINT32 newHeight,
RDP_RECT* rectangles); UINT32 numRectangles, const RECTANGLE_32* rectangles);
/* Change Gstreamer Audio Volume */ /* Change Gstreamer Audio Volume */
BOOL (*ChangeVolume)(ITSMFDecoder* decoder, UINT32 newVolume, UINT32 muted); BOOL (*ChangeVolume)(ITSMFDecoder* decoder, UINT32 newVolume, UINT32 muted);
/* Check buffer level */ /* Check buffer level */

49
channels/tsmf/client/tsmf_ifman.c
View File

@ -68,8 +68,6 @@ UINT tsmf_ifman_rim_exchange_capability_request(TSMF_IFMAN* ifman)
*/ */
UINT tsmf_ifman_exchange_capability_request(TSMF_IFMAN* ifman) UINT tsmf_ifman_exchange_capability_request(TSMF_IFMAN* ifman)
{ {
UINT32 v = 0;
UINT32 pos = 0;
UINT32 CapabilityType = 0; UINT32 CapabilityType = 0;
UINT32 cbCapabilityLength = 0; UINT32 cbCapabilityLength = 0;
UINT32 numHostCapabilities = 0; UINT32 numHostCapabilities = 0;
@ -81,9 +79,9 @@ UINT tsmf_ifman_exchange_capability_request(TSMF_IFMAN* ifman)
if (!Stream_CheckAndLogRequiredLength(TAG, ifman->input, ifman->input_size)) if (!Stream_CheckAndLogRequiredLength(TAG, ifman->input, ifman->input_size))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
pos = Stream_GetPosition(ifman->output); const size_t xpos = Stream_GetPosition(ifman->output);
Stream_Copy(ifman->input, ifman->output, ifman->input_size); Stream_Copy(ifman->input, ifman->output, ifman->input_size);
Stream_SetPosition(ifman->output, pos); Stream_SetPosition(ifman->output, xpos);
if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4)) if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -101,27 +99,33 @@ UINT tsmf_ifman_exchange_capability_request(TSMF_IFMAN* ifman)
if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, cbCapabilityLength)) if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, cbCapabilityLength))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
pos = Stream_GetPosition(ifman->output); const size_t pos = Stream_GetPosition(ifman->output);
switch (CapabilityType) switch (CapabilityType)
{ {
case 1: /* Protocol version request */ case 1: /* Protocol version request */
{
if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4)) if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Read_UINT32(ifman->output, v); const UINT32 v = Stream_Get_UINT32(ifman->output);
WINPR_UNUSED(v);
DEBUG_TSMF("server protocol version %" PRIu32 "", v); DEBUG_TSMF("server protocol version %" PRIu32 "", v);
}
break; break;
case 2: /* Supported platform */ case 2: /* Supported platform */
{
if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4)) if (!Stream_CheckAndLogRequiredLength(TAG, ifman->output, 4))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Peek_UINT32(ifman->output, v); const UINT32 v = Stream_Get_UINT32(ifman->output);
WINPR_UNUSED(v);
DEBUG_TSMF("server supported platform %" PRIu32 "", v); DEBUG_TSMF("server supported platform %" PRIu32 "", v);
/* Claim that we support both MF and DShow platforms. */ /* Claim that we support both MF and DShow platforms. */
Stream_Write_UINT32(ifman->output, MMREDIR_CAPABILITY_PLATFORM_MF | Stream_Write_UINT32(ifman->output, MMREDIR_CAPABILITY_PLATFORM_MF |
MMREDIR_CAPABILITY_PLATFORM_DSHOW); MMREDIR_CAPABILITY_PLATFORM_DSHOW);
}
break; break;
default: default:
@ -482,8 +486,7 @@ UINT tsmf_ifman_update_geometry_info(TSMF_IFMAN* ifman)
UINT32 Width = 0; UINT32 Width = 0;
UINT32 Height = 0; UINT32 Height = 0;
UINT32 cbVisibleRect = 0; UINT32 cbVisibleRect = 0;
RDP_RECT* rects = NULL; RECTANGLE_32* rects = NULL;
int num_rects = 0;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
size_t pos = 0; size_t pos = 0;
@ -505,34 +508,32 @@ UINT tsmf_ifman_update_geometry_info(TSMF_IFMAN* ifman)
Stream_Read_UINT32(ifman->input, Top); Stream_Read_UINT32(ifman->input, Top);
Stream_SetPosition(ifman->input, pos + numGeometryInfo); Stream_SetPosition(ifman->input, pos + numGeometryInfo);
Stream_Read_UINT32(ifman->input, cbVisibleRect); Stream_Read_UINT32(ifman->input, cbVisibleRect);
num_rects = cbVisibleRect / 16; const UINT32 num_rects = cbVisibleRect / 16;
DEBUG_TSMF("numGeometryInfo %" PRIu32 " Width %" PRIu32 " Height %" PRIu32 " Left %" PRIu32 DEBUG_TSMF("numGeometryInfo %" PRIu32 " Width %" PRIu32 " Height %" PRIu32 " Left %" PRIu32
" Top %" PRIu32 " cbVisibleRect %" PRIu32 " num_rects %d", " Top %" PRIu32 " cbVisibleRect %" PRIu32 " num_rects %d",
numGeometryInfo, Width, Height, Left, Top, cbVisibleRect, num_rects); numGeometryInfo, Width, Height, Left, Top, cbVisibleRect, num_rects);
if (num_rects > 0) if (num_rects > 0)
{ {
rects = (RDP_RECT*)calloc(num_rects, sizeof(RDP_RECT)); rects = (RECTANGLE_32*)calloc(num_rects, sizeof(RECTANGLE_32));
for (UINT32 i = 0; i < num_rects; i++) for (size_t i = 0; i < num_rects; i++)
{ {
Stream_Read_UINT16(ifman->input, rects[i].y); /* Top */ Stream_Read_UINT32(ifman->input, rects[i].top); /* Top */
Stream_Seek_UINT16(ifman->input); Stream_Read_UINT32(ifman->input, rects[i].left); /* Left */
Stream_Read_UINT16(ifman->input, rects[i].x); /* Left */ Stream_Read_UINT32(ifman->input, rects[i].height); /* Bottom */
Stream_Seek_UINT16(ifman->input); Stream_Read_UINT32(ifman->input, rects[i].width); /* Right */
Stream_Read_UINT16(ifman->input, rects[i].height); /* Bottom */ rects[i].width -= rects[i].left;
Stream_Seek_UINT16(ifman->input); rects[i].height -= rects[i].top;
Stream_Read_UINT16(ifman->input, rects[i].width); /* Right */
Stream_Seek_UINT16(ifman->input);
rects[i].width -= rects[i].x;
rects[i].height -= rects[i].y;
DEBUG_TSMF("rect %d: %" PRId16 " %" PRId16 " %" PRId16 " %" PRId16 "", i, rects[i].x, DEBUG_TSMF("rect %d: %" PRId16 " %" PRId16 " %" PRId16 " %" PRId16 "", i, rects[i].x,
rects[i].y, rects[i].width, rects[i].height); rects[i].y, rects[i].width, rects[i].height);
} }
} }
if (!tsmf_presentation_set_geometry_info(presentation, Left, Top, Width, Height, num_rects, const BOOL rc = tsmf_presentation_set_geometry_info(presentation, Left, Top, Width, Height,
rects)) num_rects, rects);
free(rects);
if (!rc)
return ERROR_INVALID_OPERATION; return ERROR_INVALID_OPERATION;
ifman->output_pending = TRUE; ifman->output_pending = TRUE;

39
channels/tsmf/client/tsmf_main.c
View File

@ -36,8 +36,7 @@
BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id) BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id)
{ {
wStream* s = NULL; ssize_t status = -1;
int status = -1;
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback; TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
if (!callback) if (!callback)
@ -48,7 +47,7 @@ BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32
if (callback && callback->stream_id && callback->channel && callback->channel->Write) if (callback && callback->stream_id && callback->channel && callback->channel->Write)
{ {
s = Stream_New(NULL, 24); wStream* s = Stream_New(NULL, 24);
if (!s) if (!s)
return FALSE; return FALSE;
@ -59,9 +58,10 @@ BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32
Stream_Write_UINT32(s, callback->stream_id); /* StreamId */ Stream_Write_UINT32(s, callback->stream_id); /* StreamId */
Stream_Write_UINT32(s, TSMM_CLIENT_EVENT_ENDOFSTREAM); /* EventId */ Stream_Write_UINT32(s, TSMM_CLIENT_EVENT_ENDOFSTREAM); /* EventId */
Stream_Write_UINT32(s, 0); /* cbData */ Stream_Write_UINT32(s, 0); /* cbData */
DEBUG_TSMF("EOS response size %" PRIuz "", Stream_GetPosition(s)); const size_t pos = Stream_GetPosition(s);
status = callback->channel->Write(callback->channel, Stream_GetPosition(s), DEBUG_TSMF("EOS response size %" PRIuz "", pos);
Stream_Buffer(s), NULL); WINPR_ASSERT(pos <= UINT32_MAX);
status = callback->channel->Write(callback->channel, (UINT32)pos, Stream_Buffer(s), NULL);
if (status) if (status)
{ {
@ -77,14 +77,13 @@ BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32
BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id, BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id,
UINT64 duration, UINT32 data_size) UINT64 duration, UINT32 data_size)
{ {
wStream* s = NULL; ssize_t status = -1;
int status = -1;
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback; TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
if (!callback) if (!callback)
return FALSE; return FALSE;
s = Stream_New(NULL, 32); wStream* s = Stream_New(NULL, 32);
if (!s) if (!s)
return FALSE; return FALSE;
@ -95,7 +94,9 @@ BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 mess
Stream_Write_UINT32(s, callback->stream_id); /* StreamId */ Stream_Write_UINT32(s, callback->stream_id); /* StreamId */
Stream_Write_UINT64(s, duration); /* DataDuration */ Stream_Write_UINT64(s, duration); /* DataDuration */
Stream_Write_UINT64(s, data_size); /* cbData */ Stream_Write_UINT64(s, data_size); /* cbData */
DEBUG_TSMF("ACK response size %" PRIuz "", Stream_GetPosition(s));
const size_t pos = Stream_GetPosition(s);
DEBUG_TSMF("ACK response size %" PRIuz "", pos);
if (!callback->channel || !callback->channel->Write) if (!callback->channel || !callback->channel->Write)
{ {
@ -105,8 +106,8 @@ BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 mess
} }
else else
{ {
status = callback->channel->Write(callback->channel, Stream_GetPosition(s), WINPR_ASSERT(pos <= UINT32_MAX);
Stream_Buffer(s), NULL); status = callback->channel->Write(callback->channel, (UINT32)pos, Stream_Buffer(s), NULL);
} }
if (status) if (status)
@ -125,7 +126,6 @@ BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 mess
*/ */
static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data) static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
{ {
size_t length = 0;
wStream* input = NULL; wStream* input = NULL;
wStream* output = NULL; wStream* output = NULL;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
@ -135,10 +135,10 @@ static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
UINT32 FunctionId = 0; UINT32 FunctionId = 0;
UINT32 InterfaceId = 0; UINT32 InterfaceId = 0;
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback; TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
UINT32 cbSize = Stream_GetRemainingLength(data); const size_t cbSize = Stream_GetRemainingLength(data);
/* 2.2.1 Shared Message Header (SHARED_MSG_HEADER) */ /* 2.2.1 Shared Message Header (SHARED_MSG_HEADER) */
if (!Stream_CheckAndLogRequiredLength(TAG, data, 12)) if (!Stream_CheckAndLogRequiredLength(TAG, data, 12) || (cbSize > UINT32_MAX))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
input = data; input = data;
@ -162,7 +162,7 @@ static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
ifman.stream_id = callback->stream_id; ifman.stream_id = callback->stream_id;
ifman.message_id = MessageId; ifman.message_id = MessageId;
ifman.input = input; ifman.input = input;
ifman.input_size = cbSize - 12; ifman.input_size = (UINT32)(cbSize - 12U);
ifman.output = output; ifman.output = output;
ifman.output_pending = FALSE; ifman.output_pending = FALSE;
ifman.output_interface_id = InterfaceId; ifman.output_interface_id = InterfaceId;
@ -374,12 +374,15 @@ static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
if (processed && !ifman.output_pending) if (processed && !ifman.output_pending)
{ {
/* Response packet does not have FunctionId */ /* Response packet does not have FunctionId */
length = Stream_GetPosition(output); const size_t length = Stream_GetPosition(output);
if (length > UINT32_MAX)
goto out;
Stream_SetPosition(output, 0); Stream_SetPosition(output, 0);
Stream_Write_UINT32(output, ifman.output_interface_id); Stream_Write_UINT32(output, ifman.output_interface_id);
Stream_Write_UINT32(output, MessageId); Stream_Write_UINT32(output, MessageId);
DEBUG_TSMF("response size %d", length); DEBUG_TSMF("response size %d", length);
error = callback->channel->Write(callback->channel, length, Stream_Buffer(output), NULL); error = callback->channel->Write(callback->channel, (UINT32)length, Stream_Buffer(output),
NULL);
if (error) if (error)
{ {

135
channels/tsmf/client/tsmf_media.c
View File

@ -79,13 +79,10 @@ struct S_TSMF_PRESENTATION
wArrayList* stream_list; wArrayList* stream_list;
int x; RECTANGLE_32 rect;
int y;
int width;
int height;
int nr_rects; UINT32 nr_rects;
void* rects; RECTANGLE_32* rects;
}; };
struct S_TSMF_STREAM struct S_TSMF_STREAM
@ -166,16 +163,13 @@ static UINT64 get_current_time(void)
static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync) static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
{ {
UINT32 count = 0;
TSMF_STREAM* s = NULL;
TSMF_SAMPLE* sample = NULL; TSMF_SAMPLE* sample = NULL;
BOOL pending = FALSE; BOOL pending = FALSE;
TSMF_PRESENTATION* presentation = NULL;
if (!stream) if (!stream)
return NULL; return NULL;
presentation = stream->presentation; TSMF_PRESENTATION* presentation = stream->presentation;
if (Queue_Count(stream->sample_list) < 1) if (Queue_Count(stream->sample_list) < 1)
return NULL; return NULL;
@ -196,11 +190,12 @@ static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
if (stream->last_start_time > AUDIO_TOLERANCE) if (stream->last_start_time > AUDIO_TOLERANCE)
{ {
ArrayList_Lock(presentation->stream_list); ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list); const size_t count = ArrayList_Count(presentation->stream_list);
for (UINT32 index = 0; index < count; index++) for (size_t index = 0; index < count; index++)
{ {
s = (TSMF_STREAM*)ArrayList_GetItem(presentation->stream_list, index); TSMF_STREAM* s =
(TSMF_STREAM*)ArrayList_GetItem(presentation->stream_list, index);
/* Start time is more reliable than end time as some stream types seem /* Start time is more reliable than end time as some stream types seem
* to have incorrect end times from the server * to have incorrect end times from the server
@ -391,12 +386,11 @@ static char* guid_to_string(const BYTE* guid, char* str, size_t len)
TSMF_PRESENTATION* tsmf_presentation_find_by_id(const BYTE* guid) TSMF_PRESENTATION* tsmf_presentation_find_by_id(const BYTE* guid)
{ {
UINT32 count = 0;
BOOL found = FALSE; BOOL found = FALSE;
char guid_str[GUID_SIZE * 2 + 1] = { 0 }; char guid_str[GUID_SIZE * 2 + 1] = { 0 };
TSMF_PRESENTATION* presentation = NULL; TSMF_PRESENTATION* presentation = NULL;
ArrayList_Lock(presentation_list); ArrayList_Lock(presentation_list);
count = ArrayList_Count(presentation_list); const size_t count = ArrayList_Count(presentation_list);
for (size_t index = 0; index < count; index++) for (size_t index = 0; index < count; index++)
{ {
@ -420,8 +414,8 @@ TSMF_PRESENTATION* tsmf_presentation_find_by_id(const BYTE* guid)
static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample) static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample)
{ {
UINT64 t = 0; WINPR_ASSERT(sample);
TSMF_VIDEO_FRAME_EVENT event;
TSMF_STREAM* stream = sample->stream; TSMF_STREAM* stream = sample->stream;
TSMF_PRESENTATION* presentation = stream->presentation; TSMF_PRESENTATION* presentation = stream->presentation;
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)sample->channel_callback; TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)sample->channel_callback;
@ -431,7 +425,7 @@ static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample)
if (sample->data) if (sample->data)
{ {
t = get_current_time(); const UINT64 t = get_current_time();
/* Start time is more reliable than end time as some stream types seem to have incorrect /* Start time is more reliable than end time as some stream types seem to have incorrect
* end times from the server * end times from the server
@ -440,24 +434,46 @@ static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample)
((sample->start_time >= presentation->audio_start_time) || ((sample->start_time >= presentation->audio_start_time) ||
((sample->start_time < stream->last_start_time) && (!sample->invalidTimestamps)))) ((sample->start_time < stream->last_start_time) && (!sample->invalidTimestamps))))
{ {
USleep((stream->next_start_time - t) / 10); size_t delay = (stream->next_start_time - t) / 10;
while (delay > 0)
{
const UINT32 d = (delay > UINT32_MAX) ? UINT32_MAX : (UINT32)delay;
USleep(d);
delay -= d;
}
} }
if (sample->stream->width > INT16_MAX)
return FALSE;
if (sample->stream->height > INT16_MAX)
return FALSE;
if (presentation->rect.left > INT16_MAX)
return FALSE;
if (presentation->rect.top > INT16_MAX)
return FALSE;
if (presentation->rect.width > INT16_MAX)
return FALSE;
if (presentation->rect.height > INT16_MAX)
return FALSE;
if (presentation->nr_rects > UINT16_MAX)
return FALSE;
stream->next_start_time = t + sample->duration - 50000; stream->next_start_time = t + sample->duration - 50000;
ZeroMemory(&event, sizeof(TSMF_VIDEO_FRAME_EVENT));
TSMF_VIDEO_FRAME_EVENT event = { 0 };
event.frameData = sample->data; event.frameData = sample->data;
event.frameSize = sample->decoded_size; event.frameSize = sample->decoded_size;
event.framePixFmt = sample->pixfmt; event.framePixFmt = sample->pixfmt;
event.frameWidth = sample->stream->width; event.frameWidth = (INT16)sample->stream->width;
event.frameHeight = sample->stream->height; event.frameHeight = (INT16)sample->stream->height;
event.x = presentation->x; event.x = (INT16)presentation->rect.left;
event.y = presentation->y; event.y = (INT16)presentation->rect.top;
event.width = presentation->width; event.width = (INT16)presentation->rect.width;
event.height = presentation->height; event.height = (INT16)presentation->rect.height;
if (presentation->nr_rects > 0) if (presentation->nr_rects > 0)
{ {
event.numVisibleRects = presentation->nr_rects; event.numVisibleRects = (UINT16)presentation->nr_rects;
event.visibleRects = (RECTANGLE_16*)calloc(event.numVisibleRects, sizeof(RECTANGLE_16)); event.visibleRects = (RECTANGLE_16*)calloc(event.numVisibleRects, sizeof(RECTANGLE_16));
if (!event.visibleRects) if (!event.visibleRects)
@ -466,36 +482,26 @@ static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample)
return FALSE; return FALSE;
} }
for (size_t x = 0; x < presentation->nr_rects; x++)
{
const RECTANGLE_32* cur = &presentation->rects[x];
RECTANGLE_16* dst = &event.visibleRects[x];
if ((cur->left > UINT16_MAX) || (cur->top > UINT16_MAX) ||
(cur->width > UINT16_MAX) || (cur->height > UINT16_MAX))
{
free(event.visibleRects);
return FALSE;
}
dst->right = dst->left = (UINT16)cur->left;
dst->bottom = dst->top = (UINT16)cur->top;
dst->right += (UINT16)cur->width;
dst->bottom += (UINT16)cur->height;
}
memcpy(event.visibleRects, presentation->rects, memcpy(event.visibleRects, presentation->rects,
presentation->nr_rects * sizeof(RDP_RECT)); presentation->nr_rects * sizeof(RECTANGLE_16));
presentation->nr_rects = 0; presentation->nr_rects = 0;
} }
#if 0
/* Dump a .ppm image for every 30 frames. Assuming the frame is in YUV format, we
extract the Y values to create a grayscale image. */
static int frame_id = 0;
char buf[100];
if ((frame_id % 30) == 0)
{
sprintf_s(buf, sizeof(buf), "/tmp/FreeRDP_Frame_%d.ppm", frame_id);
FILE* fp = fopen(buf, "wb");
if (fp)
{
fwrite("P5\n", 1, 3, fp);
sprintf_s(buf, sizeof(buf), "%"PRIu32" %"PRIu32"\n", sample->stream->width,
sample->stream->height);
fwrite(buf, 1, strnlen(buf, sizeof(buf)), fp);
fwrite("255\n", 1, 4, fp);
fwrite(sample->data, 1, sample->stream->width * sample->stream->height, fp);
fflush(fp);
fclose(fp);
}
}
frame_id++;
#endif
/* The frame data ownership is passed to the event object, and is freed after the event is /* The frame data ownership is passed to the event object, and is freed after the event is
* processed. */ * processed. */
sample->data = NULL; sample->data = NULL;
@ -505,8 +511,6 @@ static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample)
tsmf->FrameEvent(tsmf, &event); tsmf->FrameEvent(tsmf, &event);
free(event.frameData); free(event.frameData);
if (event.visibleRects != NULL)
free(event.visibleRects); free(event.visibleRects);
} }
@ -574,7 +578,7 @@ static BOOL tsmf_sample_playback(TSMF_SAMPLE* sample)
TSMF_STREAM* temp_stream = NULL; TSMF_STREAM* temp_stream = NULL;
TSMF_PRESENTATION* presentation = stream->presentation; TSMF_PRESENTATION* presentation = stream->presentation;
ArrayList_Lock(presentation->stream_list); ArrayList_Lock(presentation->stream_list);
int count = ArrayList_Count(presentation->stream_list); const size_t count = ArrayList_Count(presentation->stream_list);
for (size_t index = 0; index < count; index++) for (size_t index = 0; index < count; index++)
{ {
@ -1080,11 +1084,10 @@ BOOL tsmf_presentation_stop(TSMF_PRESENTATION* presentation)
} }
BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation, UINT32 x, UINT32 y, BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation, UINT32 x, UINT32 y,
UINT32 width, UINT32 height, int num_rects, UINT32 width, UINT32 height, UINT32 num_rects,
RDP_RECT* rects) const RECTANGLE_32* rects)
{ {
TSMF_STREAM* stream = NULL; TSMF_STREAM* stream = NULL;
void* tmp_rects = NULL;
BOOL ret = TRUE; BOOL ret = TRUE;
/* The server may send messages with invalid width / height. /* The server may send messages with invalid width / height.
@ -1097,19 +1100,19 @@ BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation, UINT32
* or not the window is visible. So, always process a valid message with unchanged position/size * or not the window is visible. So, always process a valid message with unchanged position/size
* and/or no visibility rects. * and/or no visibility rects.
*/ */
presentation->x = x; presentation->rect.left = x;
presentation->y = y; presentation->rect.top = y;
presentation->width = width; presentation->rect.width = width;
presentation->height = height; presentation->rect.height = height;
tmp_rects = realloc(presentation->rects, sizeof(RDP_RECT) * num_rects); void* tmp_rects = realloc(presentation->rects, sizeof(RECTANGLE_32) * num_rects);
if (!tmp_rects && num_rects) if (!tmp_rects && num_rects)
return FALSE; return FALSE;
presentation->nr_rects = num_rects; presentation->nr_rects = num_rects;
presentation->rects = tmp_rects; presentation->rects = (RECTANGLE_32*)tmp_rects;
if (presentation->rects) if (presentation->rects)
CopyMemory(presentation->rects, rects, sizeof(RDP_RECT) * num_rects); CopyMemory(presentation->rects, rects, sizeof(RECTANGLE_32) * num_rects);
ArrayList_Lock(presentation->stream_list); ArrayList_Lock(presentation->stream_list);
size_t count = ArrayList_Count(presentation->stream_list); size_t count = ArrayList_Count(presentation->stream_list);

4
channels/tsmf/client/tsmf_media.h
View File

@ -47,8 +47,8 @@ BOOL tsmf_presentation_restarted(TSMF_PRESENTATION* presentation);
BOOL tsmf_presentation_volume_changed(TSMF_PRESENTATION* presentation, UINT32 newVolume, BOOL tsmf_presentation_volume_changed(TSMF_PRESENTATION* presentation, UINT32 newVolume,
UINT32 muted); UINT32 muted);
BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation, UINT32 x, UINT32 y, BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation, UINT32 x, UINT32 y,
UINT32 width, UINT32 height, int num_rects, UINT32 width, UINT32 height, UINT32 num_rects,
RDP_RECT* rects); const RECTANGLE_32* rects);
void tsmf_presentation_set_audio_device(TSMF_PRESENTATION* presentation, const char* name, void tsmf_presentation_set_audio_device(TSMF_PRESENTATION* presentation, const char* name,
const char* device); const char* device);
void tsmf_presentation_free(TSMF_PRESENTATION* presentation); void tsmf_presentation_free(TSMF_PRESENTATION* presentation);

13
channels/urbdrc/client/libusb/libusb_udevice.c
View File

@ -784,6 +784,7 @@ static int libusb_udev_control_pipe_request(IUDEVICE* idev, UINT32 RequestId,
int error = 0; int error = 0;
UDEVICE* pdev = (UDEVICE*)idev; UDEVICE* pdev = (UDEVICE*)idev;
WINPR_ASSERT(EndpointAddress <= UINT8_MAX);
/* /*
pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0); pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0);
*/ */
@ -794,14 +795,18 @@ static int libusb_udev_control_pipe_request(IUDEVICE* idev, UINT32 RequestId,
idev->cancel_all_transfer_request(idev); idev->cancel_all_transfer_request(idev);
// dummy_wait_s_obj(1); // dummy_wait_s_obj(1);
/** set feature to ep (set halt)*/ /** set feature to ep (set halt)*/
error = libusb_control_transfer( /*
pdev->libusb_handle, LIBUSB_ENDPOINT_OUT | LIBUSB_RECIPIENT_ENDPOINT, uint8_t request_type, uint8_t bRequest,
LIBUSB_REQUEST_SET_FEATURE, ENDPOINT_HALT, EndpointAddress, NULL, 0, 1000); */
error = libusb_control_transfer(pdev->libusb_handle,
LIBUSB_ENDPOINT_OUT | LIBUSB_RECIPIENT_ENDPOINT,
LIBUSB_REQUEST_SET_FEATURE, ENDPOINT_HALT,
(uint16_t)EndpointAddress, NULL, 0, 1000);
break; break;
case PIPE_RESET: case PIPE_RESET:
idev->cancel_all_transfer_request(idev); idev->cancel_all_transfer_request(idev);
error = libusb_clear_halt(pdev->libusb_handle, EndpointAddress); error = libusb_clear_halt(pdev->libusb_handle, (uint8_t)EndpointAddress);
// func_set_usbd_status(pdev, UsbdStatus, error); // func_set_usbd_status(pdev, UsbdStatus, error);
break; break;

6
client/SDL/SDL3/dialogs/sdl_select.hpp
View File

@ -35,9 +35,9 @@ class SdlSelectWidget : public SdlWidget
SdlSelectWidget& operator=(const SdlSelectWidget& other) = delete; SdlSelectWidget& operator=(const SdlSelectWidget& other) = delete;
SdlSelectWidget& operator=(SdlSelectWidget&& other) = delete; SdlSelectWidget& operator=(SdlSelectWidget&& other) = delete;
bool set_mouseover(SDL_Renderer* renderer, bool mouseOver); virtual bool set_mouseover(SDL_Renderer* renderer, bool mouseOver);
bool set_highlight(SDL_Renderer* renderer, bool highlight); virtual bool set_highlight(SDL_Renderer* renderer, bool highlight);
bool update_text(SDL_Renderer* renderer); virtual bool update_text(SDL_Renderer* renderer);
private: private:
std::string _text; std::string _text;

8
client/SDL/SDL3/sdl_clip.cpp
View File

@ -207,7 +207,7 @@ bool sdlClip::handle_update(const SDL_ClipboardEvent& ev)
clientFormats.erase(u, clientFormats.end()); clientFormats.erase(u, clientFormats.end());
const CLIPRDR_FORMAT_LIST formatList = { const CLIPRDR_FORMAT_LIST formatList = {
.common = { .msgType = CB_FORMAT_LIST, .msgFlags = 0 }, .common = { .msgType = CB_FORMAT_LIST, .msgFlags = 0, .dataLen = 0 },
.numFormats = static_cast<UINT32>(clientFormats.size()), .numFormats = static_cast<UINT32>(clientFormats.size()),
.formats = clientFormats.data(), .formats = clientFormats.data(),
}; };
@ -258,6 +258,7 @@ UINT sdlClip::SendClientCapabilities()
.generalFlags = CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(_file) .generalFlags = CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(_file)
}; };
CLIPRDR_CAPABILITIES capabilities = { CLIPRDR_CAPABILITIES capabilities = {
.common = { .msgType = CB_TYPE_NONE, .msgFlags = 0, .dataLen = 0 },
.cCapabilitiesSets = 1, .cCapabilitiesSets = 1,
.capabilitySets = reinterpret_cast<CLIPRDR_CAPABILITY_SET*>(&generalCapabilitySet) .capabilitySets = reinterpret_cast<CLIPRDR_CAPABILITY_SET*>(&generalCapabilitySet)
}; };
@ -303,7 +304,10 @@ UINT sdlClip::SendDataResponse(const BYTE* data, size_t size)
UINT sdlClip::SendDataRequest(uint32_t formatID, const std::string& mime) UINT sdlClip::SendDataRequest(uint32_t formatID, const std::string& mime)
{ {
CLIPRDR_FORMAT_DATA_REQUEST request = { .requestedFormatId = formatID }; CLIPRDR_FORMAT_DATA_REQUEST request = {
.common = { .msgType = CB_TYPE_NONE, .msgFlags = 0, .dataLen = 0 },
.requestedFormatId = formatID
};
_request_queue.push({ formatID, mime }); _request_queue.push({ formatID, mime });

13
client/X11/xf_tsmf.c
View File

@ -405,14 +405,15 @@ static int xf_tsmf_xv_init(xfContext* xfc, TsmfClientContext* tsmf)
{ {
xv->xv_pixfmts = (UINT32*)calloc((ret + 1), sizeof(UINT32)); xv->xv_pixfmts = (UINT32*)calloc((ret + 1), sizeof(UINT32));
for (unsigned int i = 0; i < (unsigned int)ret; i++) size_t x = 0;
for (; x < (size_t)ret; x++)
{ {
xv->xv_pixfmts[i] = fo[i].id; xv->xv_pixfmts[x] = fo[x].id;
WLog_DBG(TAG, "%c%c%c%c ", ((char*)(xv->xv_pixfmts + i))[0], WLog_DBG(TAG, "%c%c%c%c ", ((char*)(xv->xv_pixfmts + x))[0],
((char*)(xv->xv_pixfmts + i))[1], ((char*)(xv->xv_pixfmts + i))[2], ((char*)(xv->xv_pixfmts + x))[1], ((char*)(xv->xv_pixfmts + x))[2],
((char*)(xv->xv_pixfmts + i))[3]); ((char*)(xv->xv_pixfmts + x))[3]);
} }
xv->xv_pixfmts[i] = 0; xv->xv_pixfmts[x] = 0;
} }
XFree(fo); XFree(fo);

2
client/common/cmdline.c
View File

@ -1208,7 +1208,7 @@ static int freerdp_client_command_line_post_filter_int(void* context, COMMAND_LI
{ {
size_t count = 0; size_t count = 0;
char** ptr = CommandLineParseCommaSeparatedValuesEx("tsmf", arg->Value, &count); char** ptr = CommandLineParseCommaSeparatedValuesEx("tsmf", arg->Value, &count);
if (!freerdp_client_add_dynamic_channel(settings, count, ptr)) if (!freerdp_client_add_dynamic_channel(settings, count, (const char* const*)ptr))
status = COMMAND_LINE_ERROR_UNEXPECTED_VALUE; status = COMMAND_LINE_ERROR_UNEXPECTED_VALUE;
CommandLineParserFree(ptr); CommandLineParserFree(ptr);
if (status) if (status)

1
include/freerdp/channels/cliprdr.h
View File

@ -36,6 +36,7 @@
/* CLIPRDR_HEADER.msgType */ /* CLIPRDR_HEADER.msgType */
typedef enum typedef enum
{ {
CB_TYPE_NONE = 0x0000, /** @since version 3.10.0 */
CB_MONITOR_READY = 0x0001, CB_MONITOR_READY = 0x0001,
CB_FORMAT_LIST = 0x0002, CB_FORMAT_LIST = 0x0002,
CB_FORMAT_LIST_RESPONSE = 0x0003, CB_FORMAT_LIST_RESPONSE = 0x0003,

4
libfreerdp/core/freerdp.c
View File

@ -1074,14 +1074,14 @@ void freerdp_set_last_error_ex(rdpContext* context, UINT32 lastError, const char
if (lastError == FREERDP_ERROR_SUCCESS) if (lastError == FREERDP_ERROR_SUCCESS)
{ {
if (WLog_IsLevelActive(context->log, WLOG_DEBUG)) if (WLog_IsLevelActive(context->log, WLOG_DEBUG))
WLog_PrintMessage(context->log, WLOG_MESSAGE_TEXT, WLOG_DEBUG, line, file, fkt, WLog_PrintMessage(context->log, WLOG_MESSAGE_TEXT, WLOG_DEBUG, (size_t)line, file, fkt,
"resetting error state"); "resetting error state");
} }
else if (context->LastError != FREERDP_ERROR_SUCCESS) else if (context->LastError != FREERDP_ERROR_SUCCESS)
{ {
if (WLog_IsLevelActive(context->log, WLOG_ERROR)) if (WLog_IsLevelActive(context->log, WLOG_ERROR))
{ {
WLog_PrintMessage(context->log, WLOG_MESSAGE_TEXT, WLOG_ERROR, line, file, fkt, WLog_PrintMessage(context->log, WLOG_MESSAGE_TEXT, WLOG_ERROR, (size_t)line, file, fkt,
"TODO: Trying to set error code %s, but %s already set!", "TODO: Trying to set error code %s, but %s already set!",
freerdp_get_last_error_name(lastError), freerdp_get_last_error_name(lastError),
freerdp_get_last_error_name(context->LastError)); freerdp_get_last_error_name(context->LastError));

2
libfreerdp/utils/helpers.c
View File

@ -24,8 +24,6 @@
#include <freerdp/version.h> #include <freerdp/version.h>
#include <freerdp/build-config.h> #include <freerdp/build-config.h>
#define STR(x) #x
char* freerdp_GetConfigFilePath(BOOL system, const char* filename) char* freerdp_GetConfigFilePath(BOOL system, const char* filename)
{ {
eKnownPathTypes id = system ? KNOWN_PATH_SYSTEM_CONFIG_HOME : KNOWN_PATH_XDG_CONFIG_HOME; eKnownPathTypes id = system ? KNOWN_PATH_SYSTEM_CONFIG_HOME : KNOWN_PATH_XDG_CONFIG_HOME;

1
winpr/include/winpr/image.h
View File

@ -136,6 +136,7 @@ extern "C"
* @return \b NULL in case of failure, a pointer to an allocated buffer otherwise. Use \b free * @return \b NULL in case of failure, a pointer to an allocated buffer otherwise. Use \b free
* as deallocator * as deallocator
*/ */
WINPR_ATTR_MALLOC(free, 1)
WINPR_API void* winpr_image_write_buffer(wImage* image, UINT32 format, size_t* size); WINPR_API void* winpr_image_write_buffer(wImage* image, UINT32 format, size_t* size);
WINPR_API int winpr_image_read_buffer(wImage* image, const BYTE* buffer, size_t size); WINPR_API int winpr_image_read_buffer(wImage* image, const BYTE* buffer, size_t size);

10
winpr/libwinpr/clipboard/synthetic.c
View File

@ -367,7 +367,15 @@ static void* clipboard_synthesize_image_bmp_to_format(wClipboard* clipboard, UIN
result = winpr_image_write_buffer(img, bmpFormat, &dsize); result = winpr_image_write_buffer(img, bmpFormat, &dsize);
if (result) if (result)
*pSize = dsize; {
if (dsize <= UINT32_MAX)
*pSize = (UINT32)dsize;
else
{
free(result);
result = NULL;
}
}
fail: fail:
free(bmp); free(bmp);

8
winpr/libwinpr/smartcard/smartcard.c
View File

@ -54,7 +54,7 @@ static const SCardApiFunctionTable* g_SCardApi = NULL;
} \ } \
return g_SCardApi->pfn##_name(__VA_ARGS__) return g_SCardApi->pfn##_name(__VA_ARGS__)
#define SCARDAPI_STUB_CALL_HANDLE(_name, ...) \ #define SCARDAPI_STUB_CALL_HANDLE(_name) \
InitOnceExecuteOnce(&g_Initialized, InitializeSCardApiStubs, NULL, NULL); \ InitOnceExecuteOnce(&g_Initialized, InitializeSCardApiStubs, NULL, NULL); \
if (!g_SCardApi || !g_SCardApi->pfn##_name) \ if (!g_SCardApi || !g_SCardApi->pfn##_name) \
{ \ { \
@ -62,9 +62,9 @@ static const SCardApiFunctionTable* g_SCardApi = NULL;
g_SCardApi, g_SCardApi ? g_SCardApi->pfn##_name : NULL); \ g_SCardApi, g_SCardApi ? g_SCardApi->pfn##_name : NULL); \
return NULL; \ return NULL; \
} \ } \
return g_SCardApi->pfn##_name(__VA_ARGS__) return g_SCardApi->pfn##_name()
#define SCARDAPI_STUB_CALL_VOID(_name, ...) \ #define SCARDAPI_STUB_CALL_VOID(_name) \
InitOnceExecuteOnce(&g_Initialized, InitializeSCardApiStubs, NULL, NULL); \ InitOnceExecuteOnce(&g_Initialized, InitializeSCardApiStubs, NULL, NULL); \
if (!g_SCardApi || !g_SCardApi->pfn##_name) \ if (!g_SCardApi || !g_SCardApi->pfn##_name) \
{ \ { \
@ -72,7 +72,7 @@ static const SCardApiFunctionTable* g_SCardApi = NULL;
g_SCardApi, g_SCardApi ? g_SCardApi->pfn##_name : NULL); \ g_SCardApi, g_SCardApi ? g_SCardApi->pfn##_name : NULL); \
return; \ return; \
} \ } \
g_SCardApi->pfn##_name(__VA_ARGS__) g_SCardApi->pfn##_name()
/** /**
* Standard Windows Smart Card API * Standard Windows Smart Card API

21
winpr/libwinpr/utils/image.c
View File

@ -267,6 +267,7 @@ fail:
* Refer to "Compressed Image File Formats: JPEG, PNG, GIF, XBM, BMP" book * Refer to "Compressed Image File Formats: JPEG, PNG, GIF, XBM, BMP" book
*/ */
WINPR_ATTR_MALLOC(free, 1)
static void* winpr_bitmap_write_buffer(const BYTE* data, size_t size, UINT32 width, UINT32 height, static void* winpr_bitmap_write_buffer(const BYTE* data, size_t size, UINT32 width, UINT32 height,
UINT32 stride, UINT32 bpp, UINT32* pSize) UINT32 stride, UINT32 bpp, UINT32* pSize)
{ {
@ -641,7 +642,8 @@ static void* winpr_convert_to_jpeg(const void* data, size_t size, UINT32 width,
const JSAMPLE* cdata = data; const JSAMPLE* cdata = data;
for (size_t x = 0; x < height; x++) for (size_t x = 0; x < height; x++)
{ {
const JDIMENSION offset = x * stride; WINPR_ASSERT(x * stride <= UINT32_MAX);
const JDIMENSION offset = (JDIMENSION)x * stride;
/* libjpeg is not const correct, we must cast here to avoid issues /* libjpeg is not const correct, we must cast here to avoid issues
* with newer C compilers type check errors */ * with newer C compilers type check errors */
@ -654,7 +656,8 @@ fail:
jpeg_finish_compress(&cinfo); jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo); jpeg_destroy_compress(&cinfo);
*pSize = outsize; WINPR_ASSERT(outsize <= UINT32_MAX);
*pSize = (UINT32)outsize;
return outbuffer; return outbuffer;
#endif #endif
} }
@ -750,7 +753,9 @@ static void* winpr_convert_to_webp(const void* data, size_t size, UINT32 width,
if (rc) if (rc)
{ {
memcpy(rc, pDstData, dstSize); memcpy(rc, pDstData, dstSize);
*pSize = dstSize;
WINPR_ASSERT(dstSize <= UINT32_MAX);
*pSize = (UINT32)dstSize;
} }
WebPFree(pDstData); WebPFree(pDstData);
return rc; return rc;
@ -944,6 +949,9 @@ static void* winpr_read_png_from_buffer(const void* data, size_t SrcSize, size_t
MEMORY_READER_STATE memory_reader_state = { 0 }; MEMORY_READER_STATE memory_reader_state = { 0 };
png_bytepp row_pointers = NULL; png_bytepp row_pointers = NULL;
png_infop info_ptr = NULL; png_infop info_ptr = NULL;
if (SrcSize > UINT32_MAX)
return NULL;
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) if (!png_ptr)
goto fail; goto fail;
@ -952,7 +960,7 @@ static void* winpr_read_png_from_buffer(const void* data, size_t SrcSize, size_t
goto fail; goto fail;
memory_reader_state.buffer = WINPR_CAST_CONST_PTR_AWAY(data, png_bytep); memory_reader_state.buffer = WINPR_CAST_CONST_PTR_AWAY(data, png_bytep);
memory_reader_state.bufsize = SrcSize; memory_reader_state.bufsize = (UINT32)SrcSize;
memory_reader_state.current_pos = 0; memory_reader_state.current_pos = 0;
png_set_read_fn(png_ptr, &memory_reader_state, read_data_memory); png_set_read_fn(png_ptr, &memory_reader_state, read_data_memory);
@ -980,7 +988,7 @@ static void* winpr_read_png_from_buffer(const void* data, size_t SrcSize, size_t
if (rc) if (rc)
{ {
char* cur = rc; char* cur = rc;
for (int i = 0; i < height; i++) for (png_uint_32 i = 0; i < height; i++)
{ {
memcpy(cur, row_pointers[i], copybytes); memcpy(cur, row_pointers[i], copybytes);
cur += stride; cur += stride;
@ -988,7 +996,8 @@ static void* winpr_read_png_from_buffer(const void* data, size_t SrcSize, size_t
*pSize = size; *pSize = size;
*pWidth = width; *pWidth = width;
*pHeight = height; *pHeight = height;
*pBpp = bpp; WINPR_ASSERT(bpp <= UINT32_MAX);
*pBpp = (UINT32)bpp;
} }
} }
fail: fail: