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

Merge pull request #12289 from akallabeth/jump-init

Browse Source 
warning cleanups
This commit is contained in:
akallabeth
2026-02-10 17:11:07 +01:00
committed by GitHub
parent cb3fb59a89 e3981d8f02
commit 103afdfb36
30 changed files with 222 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-tidy
View File

@@ -56,6 +56,7 @@ Checks: >
-hicpp-uppercase-literal-suffix,
-hicpp-vararg,
-hicpp-no-malloc,
-llvm-use-ranges,
-llvm-header-guard,
-llvm-include-order,
-llvm-qualified-auto,
@@ -63,6 +64,7 @@ Checks: >
-readability-else-after-return,
-readability-avoid-nested-conditional-operator,
-modernize-use-using,
-modernize-avoid-variadic-functions,
-modernize-use-trailing-return-type,
-modernize-return-braced-init-list,
-modernize-macro-to-enum,
@@ -78,6 +80,7 @@ Checks: >
-readability-math-missing-parentheses,
-readability-misleading-indentation,
-readability-qualified-auto,
-readability-redundant-parentheses,
-readability-suspicious-call-argument,
-readability-string-compare,
-readability-uppercase-literal-suffix,

18
channels/audin/client/pulse/audin_pulse.c
View File

@@ -139,7 +139,7 @@ static UINT audin_pulse_connect(IAudinDevice* device)
if (!pulse->context)
return ERROR_INVALID_PARAMETER;
if (pa_context_connect(pulse->context, NULL, 0, NULL))
if (pa_context_connect(pulse->context, NULL, PA_CONTEXT_NOFLAGS, NULL))
{
WLog_Print(pulse->log, WLOG_ERROR, "pa_context_connect failed (%d)",
pa_context_errno(pulse->context));
@@ -253,7 +253,6 @@ static BOOL audin_pulse_format_supported(IAudinDevice* device, const AUDIO_FORMA
static UINT audin_pulse_set_format(IAudinDevice* device, const AUDIO_FORMAT* format,
UINT32 FramesPerPacket)
{
pa_sample_spec sample_spec = { 0 };
AudinPulseDevice* pulse = (AudinPulseDevice*)device;
if (!pulse || !format)
@@ -265,21 +264,18 @@ static UINT audin_pulse_set_format(IAudinDevice* device, const AUDIO_FORMAT* for
if (FramesPerPacket > 0)
pulse->frames_per_packet = FramesPerPacket;
sample_spec.rate = format->nSamplesPerSec;
sample_spec.channels = WINPR_ASSERTING_INT_CAST(uint8_t, format->nChannels);
pa_sample_format_t sformat = PA_SAMPLE_INVALID;
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM: /* PCM */
switch (format->wBitsPerSample)
{
case 8:
sample_spec.format = PA_SAMPLE_U8;
sformat = PA_SAMPLE_U8;
break;
case 16:
sample_spec.format = PA_SAMPLE_S16LE;
sformat = PA_SAMPLE_S16LE;
break;
default:
@@ -292,6 +288,12 @@ static UINT audin_pulse_set_format(IAudinDevice* device, const AUDIO_FORMAT* for
return ERROR_INTERNAL_ERROR;
}
const pa_sample_spec sample_spec = {
.format = sformat,
.rate = format->nSamplesPerSec,
.channels = WINPR_ASSERTING_INT_CAST(uint8_t, format->nChannels),
};
pulse->sample_spec = sample_spec;
pulse->format = *format;
return CHANNEL_RC_OK;

18
channels/rdpear/client/rdpear_main.c
View File

@@ -394,9 +394,9 @@ static char* KERB_RPC_UNICODESTR_to_charptr(const RPC_UNICODE_STRING* src)
static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData, BOOL* haveData)
{
WinPrAsn1Decoder dec = { 0 };
WinPrAsn1Decoder dec2 = { 0 };
WinPrAsn1Decoder dec3 = { 0 };
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec3 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
BOOL error = FALSE;
WinPrAsn1_INTEGER adType = 0;
@@ -429,8 +429,8 @@ static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData,
static BOOL extractChecksum(const KERB_ASN1_DATA* src, krb5_checksum* dst)
{
WinPrAsn1Decoder dec = { 0 };
WinPrAsn1Decoder dec2 = { 0 };
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
BOOL error = FALSE;
WinPrAsn1_OctetString os;
@@ -626,8 +626,8 @@ out:
static BOOL rdpear_findEncryptedData(const KERB_ASN1_DATA* src, int* penctype, krb5_data* data)
{
WinPrAsn1Decoder dec = { 0 };
WinPrAsn1Decoder dec2 = { 0 };
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
BOOL error = FALSE;
WinPrAsn1_INTEGER encType = 0;
@@ -974,8 +974,8 @@ static UINT rdpear_on_data_received(IWTSVirtualChannelCallback* pChannelCallback
if (!freerdp_nla_decrypt(rdpear->rdp_context, &inBuffer, &decrypted))
goto out;
WinPrAsn1Decoder dec = { 0 };
WinPrAsn1Decoder dec2 = { 0 };
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
wStream decodedStream = { 0 };
Stream_StaticInit(&decodedStream, decrypted.pvBuffer, decrypted.cbBuffer);
WinPrAsn1Decoder_Init(&dec, WINPR_ASN1_DER, &decodedStream);

2
channels/rdpecam/CMakeLists.txt
View File

@@ -18,12 +18,14 @@
define_channel("rdpecam")
if(WITH_SERVER_CHANNELS)
include_directories(common)
add_channel_server(${MODULE_PREFIX} ${CHANNEL_NAME})
endif()
if(WITH_CLIENT_CHANNELS)
option(RDPECAM_CLIENT_CHANNEL_STUB "Only build [MS-RDPECAM] channel stub" OFF)
if(NOT RDPECAM_CLIENT_CHANNEL_STUB)
include_directories(common)
add_channel_client(${MODULE_PREFIX} ${CHANNEL_NAME})
endif()
endif()

24
channels/rdpecam/client/camera.h
View File

@@ -155,7 +155,7 @@ typedef UINT (*ICamHalEnumCallback)(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK
const char* deviceId, const char* deviceName);
/* may run in context of different thread */
typedef UINT (*ICamHalSampleCapturedCallback)(CameraDevice* dev, int streamIndex,
typedef UINT (*ICamHalSampleCapturedCallback)(CameraDevice* dev, size_t streamIndex,
const BYTE* sample, size_t size);
/** @brief interface to implement for the camera HAL*/
@@ -181,7 +181,7 @@ struct s_ICamHal
* @return if the operation was successful
* @since 3.18.0
*/
BOOL (*Activate)(ICamHal* ihal, const char* deviceId, UINT32* errorCode);
BOOL (*Activate)(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode);
/**
* callback to deactivate a given camera device
@@ -191,7 +191,7 @@ struct s_ICamHal
* @return if the operation was successful
* @since 3.18.0
*/
BOOL (*Deactivate)(ICamHal* ihal, const char* deviceId, UINT32* errorCode);
BOOL (*Deactivate)(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode);
/**
* callback that returns the list of compatible media types given a set of supported formats
@@ -205,7 +205,7 @@ struct s_ICamHal
* @return number of matched supported formats
*/
INT16(*GetMediaTypeDescriptions)
(ICamHal* ihal, const char* deviceId, int streamIndex,
(ICamHal* ihal, const char* deviceId, size_t streamIndex,
const CAM_MEDIA_FORMAT_INFO* supportedFormats, size_t nSupportedFormats,
CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes, size_t* nMediaTypes);
@@ -216,27 +216,27 @@ struct s_ICamHal
* @param streamIndex stream index number
* @param mediaType
* @param callback
* @return 0 on success, a CAM_Error otherwise
* @return \b CAM_ERROR_CODE_None on success, a CAM_Error otherwise
*/
UINT(*StartStream)
(ICamHal* ihal, CameraDevice* dev, int streamIndex, const CAM_MEDIA_TYPE_DESCRIPTION* mediaType,
ICamHalSampleCapturedCallback callback);
CAM_ERROR_CODE(*StartStream)
(ICamHal* ihal, CameraDevice* dev, size_t streamIndex,
const CAM_MEDIA_TYPE_DESCRIPTION* mediaType, ICamHalSampleCapturedCallback callback);
/**
* callback to stop a stream
* @param ihal the hal interface
* @param deviceId the name of the device
* @param streamIndex stream index number
* @return 0 on success, a CAM_Error otherwise
* @return \b CAM_ERROR_CODE_None on success, a CAM_Error otherwise
*/
UINT (*StopStream)(ICamHal* ihal, const char* deviceId, int streamIndex);
CAM_ERROR_CODE (*StopStream)(ICamHal* ihal, const char* deviceId, size_t streamIndex);
/**
* callback to free the ICamHal
* @param hal the hal interface
* @return 0 on success, a CAM_Error otherwise
* @return \b CAM_ERROR_CODE_None on success, a CAM_Error otherwise
*/
UINT (*Free)(ICamHal* ihal);
CAM_ERROR_CODE (*Free)(ICamHal* ihal);
};
typedef UINT (*PREGISTERCAMERAHAL)(IWTSPlugin* plugin, ICamHal* hal);

27
channels/rdpecam/client/camera_device_main.c
View File

@@ -22,6 +22,7 @@
#include <winpr/interlocked.h>
#include "camera.h"
#include "rdpecam-utils.h"
#define TAG CHANNELS_TAG("rdpecam-device.client")
@@ -64,14 +65,22 @@ static BOOL ecam_dev_read_media_type(wStream* s, CAM_MEDIA_TYPE_DESCRIPTION* med
{
WINPR_ASSERT(mediaType);
Stream_Read_UINT8(s, mediaType->Format);
const uint8_t format = Stream_Get_UINT8(s);
if (!rdpecam_valid_CamMediaFormat(format))
return FALSE;
mediaType->Format = WINPR_ASSERTING_INT_CAST(CAM_MEDIA_FORMAT, format);
Stream_Read_UINT32(s, mediaType->Width);
Stream_Read_UINT32(s, mediaType->Height);
Stream_Read_UINT32(s, mediaType->FrameRateNumerator);
Stream_Read_UINT32(s, mediaType->FrameRateDenominator);
Stream_Read_UINT32(s, mediaType->PixelAspectRatioNumerator);
Stream_Read_UINT32(s, mediaType->PixelAspectRatioDenominator);
Stream_Read_UINT8(s, mediaType->Flags);
const uint8_t flags = Stream_Get_UINT8(s);
if (!rdpecam_valid_MediaTypeDescriptionFlags(flags))
return FALSE;
mediaType->Flags = WINPR_ASSERTING_INT_CAST(CAM_MEDIA_TYPE_DESCRIPTION_FLAGS, flags);
return TRUE;
}
@@ -163,12 +172,12 @@ static UINT ecam_dev_send_pending(CameraDevice* dev, size_t streamIndex, CameraD
return ecam_dev_send_sample_response(dev, streamIndex, encodedSample, encodedSize);
}
static UINT ecam_dev_sample_captured_callback(CameraDevice* dev, int streamIndex,
static UINT ecam_dev_sample_captured_callback(CameraDevice* dev, size_t streamIndex,
const BYTE* sample, size_t size)
{
WINPR_ASSERT(dev);
if ((streamIndex >= ECAM_DEVICE_MAX_STREAMS) || (streamIndex < 0))
if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
return ERROR_INVALID_INDEX;
CameraDeviceStream* stream = &dev->streams[streamIndex];
@@ -228,7 +237,7 @@ static UINT ecam_dev_sample_captured_callback(CameraDevice* dev, int streamIndex
Stream_SealLength(stream->pendingSample);
stream->haveSample = TRUE;
ret = ecam_dev_send_pending(dev, WINPR_ASSERTING_INT_CAST(size_t, streamIndex), stream);
ret = ecam_dev_send_pending(dev, streamIndex, stream);
out:
LeaveCriticalSection(&stream->lock);
@@ -367,8 +376,8 @@ static UINT ecam_dev_process_start_streams_request(CameraDevice* dev,
return ERROR_INVALID_DATA;
}
UINT error = dev->ihal->StartStream(dev->ihal, dev, streamIndex, &mediaType,
ecam_dev_sample_captured_callback);
const CAM_ERROR_CODE error = dev->ihal->StartStream(dev->ihal, dev, streamIndex, &mediaType,
ecam_dev_sample_captured_callback);
if (error)
{
WLog_ERR(TAG, "StartStream failure");
@@ -656,7 +665,7 @@ static UINT ecam_dev_process_activate_device_request(CameraDevice* dev,
WINPR_ATTR_UNUSED wStream* s)
{
WINPR_ASSERT(dev);
UINT32 errorCode = 0;
CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
if (dev->ihal->Activate(dev->ihal, dev->deviceId, &errorCode))
return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
@@ -679,7 +688,7 @@ static UINT ecam_dev_process_deactivate_device_request(CameraDevice* dev,
for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
ecam_dev_stop_stream(dev, i);
UINT32 errorCode = 0;
CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
if (dev->ihal->Deactivate(dev->ihal, dev->deviceId, &errorCode))
return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);

53
channels/rdpecam/client/v4l/camera_v4l.c
View File

@@ -45,7 +45,7 @@ typedef struct
} CamV4lHal;
static CamV4lStream* cam_v4l_stream_create(const char* deviceId, int streamIndex);
static CamV4lStream* cam_v4l_stream_create(const char* deviceId, size_t streamIndex);
static void cam_v4l_stream_free(void* obj);
static void cam_v4l_stream_close_device(CamV4lStream* stream);
static UINT cam_v4l_stream_stop(CamV4lStream* stream);
@@ -154,21 +154,21 @@ static int cam_v4l_open_device(const char* deviceId, int flags)
return fd;
}
static BOOL cam_v4l_activate(ICamHal* ihal, const char* deviceId, UINT32* errorCode)
static BOOL cam_v4l_activate(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode)
{
WINPR_UNUSED(ihal);
WINPR_UNUSED(deviceId);
*errorCode = 0;
*errorCode = CAM_ERROR_CODE_None;
return TRUE;
}
static BOOL cam_v4l_deactivate(ICamHal* ihal, const char* deviceId, UINT32* errorCode)
static BOOL cam_v4l_deactivate(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode)
{
WINPR_UNUSED(ihal);
WINPR_UNUSED(deviceId);
*errorCode = 0;
*errorCode = CAM_ERROR_CODE_None;
return TRUE;
}
@@ -179,7 +179,7 @@ static BOOL cam_v4l_deactivate(ICamHal* ihal, const char* deviceId, UINT32* erro
* in
*/
static INT16 cam_v4l_get_media_type_descriptions(ICamHal* ihal, const char* deviceId,
int streamIndex,
size_t streamIndex,
const CAM_MEDIA_FORMAT_INFO* supportedFormats,
size_t nSupportedFormats,
CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes,
@@ -520,7 +520,8 @@ void cam_v4l_stream_close_device(CamV4lStream* stream)
*
* @return Null on failure, otherwise pointer to new CamV4lStream
*/
static CamV4lStream* cam_v4l_stream_create(const char* deviceId, int streamIndex)
WINPR_ATTR_MALLOC(cam_v4l_stream_free, 1)
CamV4lStream* cam_v4l_stream_create(const char* deviceId, size_t streamIndex)
{
CamV4lStream* stream = calloc(1, sizeof(CamV4lStream));
@@ -548,10 +549,10 @@ static CamV4lStream* cam_v4l_stream_create(const char* deviceId, int streamIndex
*
* @return 0 on success, otherwise a Win32 error code
*/
UINT cam_v4l_stream_stop(CamV4lStream* stream)
CAM_ERROR_CODE cam_v4l_stream_stop(CamV4lStream* stream)
{
if (!stream || !stream->streaming)
return CHANNEL_RC_OK;
return CAM_ERROR_CODE_None;
stream->streaming = FALSE; /* this will terminate capture thread */
@@ -578,33 +579,29 @@ UINT cam_v4l_stream_stop(CamV4lStream* stream)
LeaveCriticalSection(&stream->lock);
return CHANNEL_RC_OK;
return CAM_ERROR_CODE_None;
}
/**
* Function description
*
* @return 0 on success, otherwise CAM_ERROR_CODE
*/
static UINT cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, int streamIndex,
const CAM_MEDIA_TYPE_DESCRIPTION* mediaType,
ICamHalSampleCapturedCallback callback)
static CAM_ERROR_CODE cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, size_t streamIndex,
const CAM_MEDIA_TYPE_DESCRIPTION* mediaType,
ICamHalSampleCapturedCallback callback)
{
CamV4lHal* hal = (CamV4lHal*)ihal;
WINPR_ASSERT(hal);
CamV4lStream* stream = (CamV4lStream*)HashTable_GetItemValue(hal->streams, dev->deviceId);
if (!stream)
{
WLog_ERR(TAG, "Unable to find stream, device %s, streamIndex %d", dev->deviceId,
WLog_ERR(TAG, "Unable to find stream, device %s, streamIndex %" PRIuz, dev->deviceId,
streamIndex);
return CAM_ERROR_CODE_UnexpectedError;
}
if (stream->streaming)
{
WLog_ERR(TAG, "Streaming already in progress, device %s, streamIndex %d", dev->deviceId,
streamIndex);
WLog_ERR(TAG, "Streaming already in progress, device %s, streamIndex %" PRIuz,
dev->deviceId, streamIndex);
return CAM_ERROR_CODE_UnexpectedError;
}
@@ -724,7 +721,7 @@ static UINT cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, int streamInd
mediaType->Width, mediaType->Height, mediaType->FrameRateNumerator,
mediaType->FrameRateDenominator);
return CHANNEL_RC_OK;
return CAM_ERROR_CODE_None;
}
/**
@@ -732,15 +729,15 @@ static UINT cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, int streamInd
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT cam_v4l_stream_stop_by_device_id(ICamHal* ihal, const char* deviceId,
WINPR_ATTR_UNUSED int streamIndex)
static CAM_ERROR_CODE cam_v4l_stream_stop_by_device_id(ICamHal* ihal, const char* deviceId,
WINPR_ATTR_UNUSED size_t streamIndex)
{
CamV4lHal* hal = (CamV4lHal*)ihal;
CamV4lStream* stream = (CamV4lStream*)HashTable_GetItemValue(hal->streams, deviceId);
if (!stream)
return CHANNEL_RC_OK;
return CAM_ERROR_CODE_NotInitialized;
return cam_v4l_stream_stop(stream);
}
@@ -768,18 +765,18 @@ void cam_v4l_stream_free(void* obj)
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT cam_v4l_free(ICamHal* ihal)
static CAM_ERROR_CODE cam_v4l_free(ICamHal* ihal)
{
CamV4lHal* hal = (CamV4lHal*)ihal;
if (hal == NULL)
return ERROR_INVALID_PARAMETER;
return CAM_ERROR_CODE_NotInitialized;
HashTable_Free(hal->streams);
free(hal);
return CHANNEL_RC_OK;
return CAM_ERROR_CODE_None;
}
/**

2
channels/rdpecam/client/v4l/camera_v4l.h
View File

@@ -38,7 +38,7 @@ typedef struct
/* members used to call the callback */
CameraDevice* dev;
int streamIndex;
size_t streamIndex;
ICamHalSampleCapturedCallback sampleCallback;
BOOL streaming;

0
channels/rdpecam/server/rdpecam-utils.h → channels/rdpecam/common/rdpecam-utils.h
View File

2
channels/rdpecam/server/CMakeLists.txt
View File

@@ -17,7 +17,7 @@
define_channel_server("rdpecam")
set(${MODULE_PREFIX}_SRCS camera_device_enumerator_main.c camera_device_main.c rdpecam-utils.h)
set(${MODULE_PREFIX}_SRCS camera_device_enumerator_main.c camera_device_main.c)
set(${MODULE_PREFIX}_LIBS freerdp)

16
channels/rdpsnd/client/pulse/rdpsnd_pulse.c
View File

@@ -171,7 +171,7 @@ static BOOL rdpsnd_pulse_connect(rdpsndDevicePlugin* device)
pa_threaded_mainloop_lock(pulse->mainloop);
if (pa_context_connect(pulse->context, NULL, 0, NULL) < 0)
if (pa_context_connect(pulse->context, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0)
{
pa_threaded_mainloop_unlock(pulse->mainloop);
return FALSE;
@@ -301,8 +301,6 @@ static void rdpsnd_pulse_close(rdpsndDevicePlugin* device)
static BOOL rdpsnd_pulse_set_format_spec(rdpsndPulsePlugin* pulse, const AUDIO_FORMAT* format)
{
pa_sample_spec sample_spec = { 0 };
WINPR_ASSERT(format);
if (!rdpsnd_check_pulse(pulse, FALSE))
@@ -311,20 +309,18 @@ static BOOL rdpsnd_pulse_set_format_spec(rdpsndPulsePlugin* pulse, const AUDIO_F
if (!rdpsnd_pulse_format_supported(&pulse->device, format))
return FALSE;
sample_spec.rate = format->nSamplesPerSec;
sample_spec.channels = WINPR_ASSERTING_INT_CAST(uint8_t, format->nChannels);
pa_sample_format_t sformat = PA_SAMPLE_INVALID;
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM:
switch (format->wBitsPerSample)
{
case 8:
sample_spec.format = PA_SAMPLE_U8;
sformat = PA_SAMPLE_U8;
break;
case 16:
sample_spec.format = PA_SAMPLE_S16LE;
sformat = PA_SAMPLE_S16LE;
break;
default:
@@ -337,6 +333,10 @@ static BOOL rdpsnd_pulse_set_format_spec(rdpsndPulsePlugin* pulse, const AUDIO_F
return FALSE;
}
const pa_sample_spec sample_spec = { .format = sformat,
.rate = format->nSamplesPerSec,
.channels =
WINPR_ASSERTING_INT_CAST(uint8_t, format->nChannels) };
pulse->sample_spec = sample_spec;
return TRUE;
}

16
client/SDL/SDL2/dialogs/sdl_connection_dialog.cpp
View File

@@ -57,7 +57,7 @@ bool SDLConnectionDialog::visible() const
bool SDLConnectionDialog::setTitle(const char* fmt, ...)
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
va_list ap = {};
va_start(ap, fmt);
_title = print(fmt, ap);
@@ -97,25 +97,25 @@ bool SDLConnectionDialog::showError(const char* fmt, ...)
bool SDLConnectionDialog::show()
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
return show(_type_active);
}
bool SDLConnectionDialog::hide()
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
return show(MSG_DISCARD);
}
bool SDLConnectionDialog::running() const
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
return _running;
}
bool SDLConnectionDialog::update()
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
switch (_type)
{
case MSG_INFO:
@@ -169,7 +169,7 @@ bool SDLConnectionDialog::clearWindow(SDL_Renderer* renderer)
bool SDLConnectionDialog::update(SDL_Renderer* renderer)
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
if (!renderer)
return false;
@@ -433,7 +433,7 @@ void SDLConnectionDialog::destroyWindow()
bool SDLConnectionDialog::show(MsgType type, const char* fmt, va_list ap)
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
_msg = print(fmt, ap);
return show(type);
}
@@ -470,7 +470,7 @@ std::string SDLConnectionDialog::print(const char* fmt, va_list ap)
bool SDLConnectionDialog::setTimer(Uint32 timeoutMS)
{
std::lock_guard lock(_mux);
std::scoped_lock lock(_mux);
resetTimer();
_timer = SDL_AddTimer(timeoutMS, &SDLConnectionDialog::timeout, this);

2
client/SDL/SDL3/dialogs/sdl_buttons.cpp
View File

@@ -25,7 +25,7 @@ bool SdlButtonList::populate(std::shared_ptr<SDL_Renderer>& renderer,
const size_t curOffsetX = offsetX + x * (static_cast<size_t>(width) + hpadding);
const SDL_FRect rect = { static_cast<float>(curOffsetX), static_cast<float>(offsetY),
static_cast<float>(width), static_cast<float>(height) };
std::shared_ptr<SdlButton> button(new SdlButton(renderer, labels[x], ids[x], rect));
auto button = std::make_shared<SdlButton>(renderer, labels[x], ids[x], rect);
_list.emplace_back(button);
}
return true;

2
client/SDL/SDL3/dialogs/sdl_input_widget_pair.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include <vector>
#include <memory>
#include <string>
#include <SDL3/SDL.h>

4
client/SDL/SDL3/dialogs/sdl_input_widget_pair_list.cpp
View File

@@ -50,8 +50,8 @@ SdlInputWidgetPairList::SdlInputWidgetPairList(const std::string& title,
{
for (size_t x = 0; x < labels.size(); x++)
{
std::shared_ptr<SdlInputWidgetPair> widget(new SdlInputWidgetPair(
_renderer, labels[x], initial[x], flags[x], x, widget_width, widget_heigth));
auto widget = std::make_shared<SdlInputWidgetPair>(
_renderer, labels[x], initial[x], flags[x], x, widget_width, widget_heigth);
m_list.emplace_back(widget);
}

2
client/X11/xf_utils.c
View File

@@ -92,7 +92,6 @@ static int write_result_log_expect_success(wLog* log, DWORD level, const char* f
{
va_list ap;
(void)write_result_log_va(log, level, fname, fkt, line, display, name, rc, 0, ap);
va_end(ap);
}
return rc;
}
@@ -104,7 +103,6 @@ static int write_result_log_expect_one(wLog* log, DWORD level, const char* fname
{
va_list ap;
(void)write_result_log_va(log, level, fname, fkt, line, display, name, rc, 0, ap);
va_end(ap);
}
return rc;
}

6
cmake/ClangTidy.cmake
View File

@@ -4,10 +4,10 @@ if(BUILD_WITH_CLANG_TIDY)
include(ClangDetectTool)
clang_detect_tool(CLANG_TIDY_EXE clang-tidy REQUIRED)
set(CLANG_TIDY_COMMAND "${CLANG_TIDY_EXE}")
set(CLANG_TIDY_COMMAND ${CLANG_TIDY_EXE})
set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY_COMMAND}" --extra-arg=-std=gnu11)
set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}" --extra-arg=-std=gnu++17)
set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
set(CMAKE_OBJC_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
else()
unset(CMAKE_C_CLANG_TIDY)

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

@@ -45,6 +45,7 @@ typedef struct
typedef enum
{
SNDIN_VERSION_Invalid = 0x00000000,
SNDIN_VERSION_Version_1 = 0x00000001,
SNDIN_VERSION_Version_2 = 0x00000002,
} SNDIN_VERSION_Version;

3
include/freerdp/channels/rdpecam.h
View File

@@ -39,6 +39,7 @@ extern "C"
typedef enum
{
CAM_MSG_ID_Invalid = 0x00,
CAM_MSG_ID_SuccessResponse = 0x01,
CAM_MSG_ID_ErrorResponse = 0x02,
CAM_MSG_ID_SelectVersionRequest = 0x03,
@@ -107,6 +108,7 @@ typedef struct
typedef enum
{
CAM_ERROR_CODE_None = 0x00000000,
CAM_ERROR_CODE_UnexpectedError = 0x00000001,
CAM_ERROR_CODE_InvalidMessage = 0x00000002,
CAM_ERROR_CODE_NotInitialized = 0x00000003,
@@ -187,6 +189,7 @@ typedef enum
typedef enum
{
AM_MEDIA_TYPE_DESCRIPTION_FLAG_Invalid = 0x00,
CAM_MEDIA_TYPE_DESCRIPTION_FLAG_DecodingRequired = 0x01,
CAM_MEDIA_TYPE_DESCRIPTION_FLAG_BottomUpImage = 0x02,
} CAM_MEDIA_TYPE_DESCRIPTION_FLAGS;

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

@@ -1120,43 +1120,79 @@ fail:
return res;
}
static BOOL readUInt(FILE* fp, const char* prefix, const char* postfix, UINT32* pval)
{
WINPR_ASSERT(fp);
WINPR_ASSERT(prefix);
WINPR_ASSERT(postfix);
WINPR_ASSERT(pval);
BOOL rc = FALSE;
const size_t plen = strlen(prefix);
const size_t polen = strlen(postfix);
char* str = NULL;
size_t len = SIZE_MAX;
const INT64 res = GetLine(&str, &len, fp);
if ((res < plen + polen) || !str)
goto fail;
if (strncmp(str, prefix, plen) != 0)
goto fail;
char* start = &str[plen];
char* end = strstr(start, postfix);
if (!end)
goto fail;
*end = '\0';
errno = 0;
unsigned long val = strtoul(start, NULL, 0);
if ((errno != 0) || (val > UINT32_MAX))
goto fail;
*pval = val;
rc = TRUE;
fail:
free(str);
return rc;
}
static BOOL read_cmd(FILE* fp, RDPGFX_SURFACE_COMMAND* cmd, UINT32* frameId)
{
WINPR_ASSERT(fp);
WINPR_ASSERT(cmd);
WINPR_ASSERT(frameId);
// NOLINTBEGIN(cert-err34-c)
if (1 != fscanf(fp, "frameid: %" PRIu32 "\n", frameId))
if (!readUInt(fp, "frameid: ", "\n", frameId))
return FALSE;
if (1 != fscanf(fp, "surfaceId: %" PRIu32 "\n", &cmd->surfaceId))
if (!readUInt(fp, "surfaceId: ", "\n", &cmd->surfaceId))
return FALSE;
if (1 != fscanf(fp, "codecId: %" PRIu32 "\n", &cmd->codecId))
if (!readUInt(fp, "codecId: ", "\n", &cmd->codecId))
return FALSE;
if (1 != fscanf(fp, "contextId: %" PRIu32 "\n", &cmd->contextId))
if (!readUInt(fp, "contextId: ", "\n", &cmd->contextId))
return FALSE;
if (1 != fscanf(fp, "format: %" PRIu32 "\n", &cmd->format))
if (!readUInt(fp, "format: ", "\n", &cmd->format))
return FALSE;
if (1 != fscanf(fp, "left: %" PRIu32 "\n", &cmd->left))
if (!readUInt(fp, "left: ", "\n", &cmd->left))
return FALSE;
if (1 != fscanf(fp, "top: %" PRIu32 "\n", &cmd->top))
if (!readUInt(fp, "top: ", "\n", &cmd->top))
return FALSE;
if (1 != fscanf(fp, "right: %" PRIu32 "\n", &cmd->right))
if (!readUInt(fp, "right: ", "\n", &cmd->right))
return FALSE;
if (1 != fscanf(fp, "bottom: %" PRIu32 "\n", &cmd->bottom))
if (!readUInt(fp, "bottom: ", "\n", &cmd->bottom))
return FALSE;
if (1 != fscanf(fp, "width: %" PRIu32 "\n", &cmd->width))
if (!readUInt(fp, "width: ", "\n", &cmd->width))
return FALSE;
if (1 != fscanf(fp, "height: %" PRIu32 "\n", &cmd->height))
if (!readUInt(fp, "height: ", "\n", &cmd->height))
return FALSE;
if (1 != fscanf(fp, "length: %" PRIu32 "\n", &cmd->length))
if (!readUInt(fp, "length: ", "\n", &cmd->length))
return FALSE;
// NOLINTEND(cert-err34-c)
char* data = NULL;
size_t dlen = SIZE_MAX;
SSIZE_T slen = GetLine(&data, &slen, fp);
INT64 slen = GetLine(&data, &dlen, fp);
if (slen < 0)
return FALSE;

6
libfreerdp/common/assistance.c
View File

@@ -868,8 +868,8 @@ BYTE* freerdp_assistance_encrypt_pass_stub(const char* password, const char* pas
WCHAR* PasswordW = ConvertUtf8ToWCharAlloc(password, &cbPasswordW);
WCHAR* PassStubW = ConvertUtf8ToWCharAlloc(passStub, &cbPassStubW);
cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
cbPassStubW = (cbPassStubW) * sizeof(WCHAR);
cbPasswordW = cbPasswordW * sizeof(WCHAR);
cbPassStubW = cbPassStubW * sizeof(WCHAR);
const size_t EncryptedSize = cbPassStubW + 4;
if (!PasswordW || !PassStubW)
@@ -945,7 +945,7 @@ static BOOL freerdp_assistance_decrypt2(rdpAssistanceFile* file)
return FALSE;
}
cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
cbPasswordW = cbPasswordW * sizeof(WCHAR);
if (!winpr_Digest(WINPR_MD_SHA1, (BYTE*)PasswordW, cbPasswordW, PasswordHash,
sizeof(PasswordHash)))

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

@@ -3,6 +3,7 @@
#include <stdlib.h>
#include <math.h>
#include <errno.h>
#include "prim_test.h"
@@ -1413,10 +1414,21 @@ int TestPrimitivesYUV(int argc, char* argv[])
if (argc > 1)
{
// NOLINTNEXTLINE(cert-err34-c)
int crc = sscanf(argv[1], "%" PRIu32 "x%" PRIu32, &roi.width, &roi.height);
BOOL reset = TRUE;
char* str = argv[1];
char* ptr = strchr(str, 'x');
if (ptr)
{
*ptr++ = '\0';
if (crc != 2)
errno = 0;
roi.width = strtoul(str, NULL, 0);
if (errno == 0)
roi.height = strtoul(str, NULL, 0);
reset = errno != 0;
}
if (reset)
{
roi.width = 1920;
roi.height = 1080;

16
libfreerdp/utils/http.c
View File

@@ -233,10 +233,20 @@ BOOL freerdp_http_request(const char* url, const char* body, long* status_code,
goto out;
}
// NOLINTNEXTLINE(cert-err34-c)
if (sscanf(buffer, "HTTP/1.1 %li %*[^\r\n]\r\n", status_code) < 1)
const char header[9] = { 'H', 'T', 'T', 'P', '/', '1', '.', '1', ' ' };
if ((status < (INT64)sizeof(header)) || (strncmp(header, buffer, sizeof(header)) != 0))
{
WLog_Print(log, WLOG_ERROR, "invalid HTTP status line");
WLog_Print(log, WLOG_ERROR, "invalid HTTP status header");
goto out;
}
errno = 0;
*status_code = strtol(&buffer[sizeof(header)], NULL, 0);
if (errno != 0)
{
char ebuffer[256] = { 0 };
WLog_Print(log, WLOG_ERROR, "invalid HTTP status line: %s [%d]",
winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
goto out;
}

13
winpr/libwinpr/smartcard/smartcard_pcsc.c
View File

@@ -2510,11 +2510,10 @@ static LONG WINAPI PCSC_SCardGetAttrib_FriendlyName(SCARDHANDLE hCard, DWORD dwA
return status;
}
static LONG PCSC_ReadDeviceSystemName(SCARDCONTEXT hContext, SCARDHANDLE hCard, DWORD dwAttrId,
LPBYTE pbAttr, LPDWORD pcbAttrLen)
static LONG PCSC_ReadDeviceSystemName(WINPR_ATTR_UNUSED SCARDCONTEXT hContext, SCARDHANDLE hCard,
DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen)
{
/* Get reader name from SCardStatus */
CHAR* szReader = NULL;
PCSC_DWORD dwState = 0;
PCSC_DWORD dwProtocol = 0;
LONG status = 0;
@@ -2531,7 +2530,7 @@ static LONG PCSC_ReadDeviceSystemName(SCARDCONTEXT hContext, SCARDHANDLE hCard,
const PCSC_LONG rc = g_PCSC.pfnSCardStatus(hCard, (LPSTR)pbAttr, &cchReader, &dwState,
&dwProtocol, NULL, &cbAtr);
*pcbAttrLen = cchReader;
*pcbAttrLen = WINPR_ASSERTING_INT_CAST(DWORD, cchReader);
status = WINPR_ASSERTING_INT_CAST(LONG, rc);
if (status != SCARD_S_SUCCESS)
return status;
@@ -2552,7 +2551,7 @@ static LONG PCSC_ReadDeviceSystemName(SCARDCONTEXT hContext, SCARDHANDLE hCard,
free(tmp);
return SCARD_E_INSUFFICIENT_BUFFER;
}
*pcbAttrLen = MIN(wlen, cchReader) * sizeof(WCHAR);
*pcbAttrLen = WINPR_ASSERTING_INT_CAST(DWORD, MIN(wlen, cchReader) * sizeof(WCHAR));
memcpy(pbAttr, tmp, *pcbAttrLen);
free(tmp);
}
@@ -2566,7 +2565,7 @@ static LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE
DWORD cbAttrLen = 0;
SCARDCONTEXT hContext = 0;
BOOL pcbAttrLenAlloc = FALSE;
LONG status = SCARD_S_SUCCESS;
PCSC_LONG status = SCARD_S_SUCCESS;
if (NULL == pcbAttrLen)
return SCARD_E_INVALID_PARAMETER;
@@ -2742,7 +2741,7 @@ static LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE
}
}
return status;
return WINPR_ASSERTING_INT_CAST(LONG, status);
}
static LONG WINAPI PCSC_SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,

16
winpr/libwinpr/sspi/Negotiate/negotiate.c
View File

@@ -477,13 +477,13 @@ cleanup:
static BOOL negotiate_read_neg_token(PSecBuffer input, NegToken* token)
{
WinPrAsn1Decoder dec;
WinPrAsn1Decoder dec2;
WinPrAsn1_OID oid;
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1_OID oid = { 0 };
WinPrAsn1_tagId contextual = 0;
WinPrAsn1_tag tag = 0;
size_t len = 0;
WinPrAsn1_OctetString octet_string;
WinPrAsn1_OctetString octet_string = { 0 };
BOOL err = 0;
WINPR_ASSERT(input);
@@ -990,8 +990,8 @@ static SECURITY_STATUS SEC_ENTRY negotiate_InitializeSecurityContextA(
static const Mech* guessMech(PSecBuffer input_buffer, BOOL* spNego, WinPrAsn1_OID* oid)
{
WinPrAsn1Decoder decoder;
WinPrAsn1Decoder appDecoder;
WinPrAsn1Decoder decoder = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder appDecoder = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1_tagId tag = 0;
const char ssp[] = "NTLMSSP";
@@ -1039,8 +1039,8 @@ static SECURITY_STATUS SEC_ENTRY negotiate_AcceptSecurityContext(
SecBufferDesc mech_input = { SECBUFFER_VERSION, 1, &input_token.mechToken };
SecBufferDesc mech_output = { SECBUFFER_VERSION, 1, &output_token.mechToken };
SECURITY_STATUS status = SEC_E_INTERNAL_ERROR;
WinPrAsn1Decoder dec;
WinPrAsn1Decoder dec2;
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1_tagId tag = 0;
WinPrAsn1_OID oid = { 0 };
const Mech* first_mech = NULL;

4
winpr/libwinpr/sspi/sspi_gss.c
View File

@@ -86,8 +86,8 @@ cleanup:
BOOL sspi_gss_unwrap_token(const SecBuffer* buf, WinPrAsn1_OID* oid, uint16_t* tok_id,
sspi_gss_data* token)
{
WinPrAsn1Decoder dec;
WinPrAsn1Decoder dec2;
WinPrAsn1Decoder dec = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder dec2 = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1_tagId tag = 0;
wStream sbuffer = { 0 };
wStream* s = NULL;

10
winpr/libwinpr/utils/asn1/asn1.c
View File

@@ -1388,7 +1388,7 @@ size_t WinPrAsn1DecReadContextualBool(WinPrAsn1Decoder* dec, WinPrAsn1_tagId tag
{
size_t ret = 0;
size_t ret2 = 0;
WinPrAsn1Decoder content;
WinPrAsn1Decoder content = { .encoding = WINPR_ASN1_BER, { 0 } };
ret = readContextualHeader(dec, tagId, error, &content);
if (!ret)
@@ -1410,7 +1410,7 @@ size_t WinPrAsn1DecReadContextualInteger(WinPrAsn1Decoder* dec, WinPrAsn1_tagId
{
size_t ret = 0;
size_t ret2 = 0;
WinPrAsn1Decoder content;
WinPrAsn1Decoder content = { .encoding = WINPR_ASN1_BER, { 0 } };
ret = readContextualHeader(dec, tagId, error, &content);
if (!ret)
@@ -1432,7 +1432,7 @@ size_t WinPrAsn1DecReadContextualOID(WinPrAsn1Decoder* dec, WinPrAsn1_tagId tagI
{
size_t ret = 0;
size_t ret2 = 0;
WinPrAsn1Decoder content;
WinPrAsn1Decoder content = { .encoding = WINPR_ASN1_BER, { 0 } };
ret = readContextualHeader(dec, tagId, error, &content);
if (!ret)
@@ -1455,7 +1455,7 @@ size_t WinPrAsn1DecReadContextualOctetString(WinPrAsn1Decoder* dec, WinPrAsn1_ta
{
size_t ret = 0;
size_t ret2 = 0;
WinPrAsn1Decoder content;
WinPrAsn1Decoder content = { .encoding = WINPR_ASN1_BER, { 0 } };
ret = readContextualHeader(dec, tagId, error, &content);
if (!ret)
@@ -1477,7 +1477,7 @@ size_t WinPrAsn1DecReadContextualSequence(WinPrAsn1Decoder* dec, WinPrAsn1_tagId
{
size_t ret = 0;
size_t ret2 = 0;
WinPrAsn1Decoder content;
WinPrAsn1Decoder content = { .encoding = WINPR_ASN1_BER, { 0 } };
ret = readContextualHeader(dec, tagId, error, &content);
if (!ret)

10
winpr/libwinpr/utils/test/TestASN1.c
View File

@@ -30,14 +30,14 @@ static const BYTE utctimeContent[] = { 0x17, 0x0D, 0x32, 0x31, 0x30, 0x33, 0x31,
int TestASN1Read(int argc, char* argv[])
{
WinPrAsn1Decoder decoder;
WinPrAsn1Decoder seqDecoder;
wStream staticS;
WinPrAsn1Decoder decoder = { .encoding = WINPR_ASN1_BER, { 0 } };
WinPrAsn1Decoder seqDecoder = { .encoding = WINPR_ASN1_BER, { 0 } };
wStream staticS = { 0 };
WinPrAsn1_BOOL boolV = 0;
WinPrAsn1_INTEGER integerV = 0;
WinPrAsn1_OID oidV;
WinPrAsn1_OID oidV = { 0 };
WinPrAsn1_IA5STRING ia5stringV = NULL;
WinPrAsn1_UTCTIME utctimeV;
WinPrAsn1_UTCTIME utctimeV = { 0 };
WinPrAsn1_tag tag = 0;
size_t len = 0;
BOOL error = 0;

2
winpr/libwinpr/utils/winpr.c
View File

@@ -57,7 +57,7 @@ static BOOL CALLBACK init_app_details(WINPR_ATTR_UNUSED PINIT_ONCE once,
return FALSE;
#if defined(WITH_RESOURCE_VERSIONING)
s_winpr_version = WINPR_API_VERSION;
s_winpr_version = WINPR_VERSION_MAJOR;
#else
s_winpr_version = -1;
#endif

5
winpr/libwinpr/wtsapi/test/TestWtsApiExtraStartRemoteSessionEx.c
View File

@@ -16,7 +16,10 @@ int TestWtsApiExtraStartRemoteSessionEx(int argc, char* argv[])
DWORD bSuccess = GetEnvironmentVariableA("TEST_SESSION_LOGON_ID", logonIdStr, 10);
if (bSuccess > 0)
{
sscanf(logonIdStr, "%u\n", &logonId);
errno = 0;
logonId = strtoul(logonIdStr, NULL, 0);
if (errno != 0)
return -1;
}
bSuccess = WTSStartRemoteControlSessionEx(