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

[stream] use const correct Stream_Pointer access

Browse Source
This commit is contained in:
Armin Novak 2023-06-07 15:38:21 +02:00 committed by David Fort
parent 2de7399e52
commit 970f0c54e8
54 changed files with 172 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
channels/cliprdr/cliprdr_common.c
View File

@ -343,7 +343,7 @@ UINT cliprdr_read_format_data_response(wStream* s, CLIPRDR_FORMAT_DATA_RESPONSE*
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
if (response->common.dataLen) if (response->common.dataLen)
response->requestedFormatData = Stream_Pointer(s); response->requestedFormatData = Stream_ConstPointer(s);
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
} }
@ -379,7 +379,7 @@ UINT cliprdr_read_file_contents_response(wStream* s, CLIPRDR_FILE_CONTENTS_RESPO
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Read_UINT32(s, response->streamId); /* streamId (4 bytes) */ Stream_Read_UINT32(s, response->streamId); /* streamId (4 bytes) */
response->requestedData = Stream_Pointer(s); /* requestedFileContentsData */ response->requestedData = Stream_ConstPointer(s); /* requestedFileContentsData */
WINPR_ASSERT(response->common.dataLen >= 4); WINPR_ASSERT(response->common.dataLen >= 4);
response->cbRequested = response->common.dataLen - 4; response->cbRequested = response->common.dataLen - 4;
@ -389,23 +389,22 @@ UINT cliprdr_read_file_contents_response(wStream* s, CLIPRDR_FILE_CONTENTS_RESPO
UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL useLongFormatNames) UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL useLongFormatNames)
{ {
UINT32 index; UINT32 index;
BOOL asciiNames;
int formatNameLength; int formatNameLength;
char* szFormatName; const char* szFormatName = NULL;
WCHAR* wszFormatName; const WCHAR* wszFormatName = NULL;
wStream sub1buffer = { 0 }; wStream sub1buffer = { 0 };
wStream* sub1;
CLIPRDR_FORMAT* formats = NULL; CLIPRDR_FORMAT* formats = NULL;
UINT error = ERROR_INTERNAL_ERROR; UINT error = ERROR_INTERNAL_ERROR;
asciiNames = (formatList->common.msgFlags & CB_ASCII_NAMES) ? TRUE : FALSE; const BOOL asciiNames = (formatList->common.msgFlags & CB_ASCII_NAMES) ? TRUE : FALSE;
index = 0; index = 0;
/* empty format list */ /* empty format list */
formatList->formats = NULL; formatList->formats = NULL;
formatList->numFormats = 0; formatList->numFormats = 0;
sub1 = Stream_StaticInit(&sub1buffer, Stream_Pointer(s), formatList->common.dataLen); wStream* sub1 =
Stream_StaticConstInit(&sub1buffer, Stream_ConstPointer(s), formatList->common.dataLen);
if (!Stream_SafeSeek(s, formatList->common.dataLen)) if (!Stream_SafeSeek(s, formatList->common.dataLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -448,8 +447,8 @@ UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL
* These are 16 unicode charaters - *without* terminating null ! * These are 16 unicode charaters - *without* terminating null !
*/ */
szFormatName = (char*)Stream_Pointer(sub1); szFormatName = Stream_ConstPointer(sub1);
wszFormatName = (WCHAR*)Stream_Pointer(sub1); wszFormatName = Stream_ConstPointer(sub1);
if (!Stream_SafeSeek(sub1, 32)) if (!Stream_SafeSeek(sub1, 32))
goto error_out; goto error_out;
@ -494,7 +493,7 @@ UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL
if (!Stream_SafeSeek(sub1, 4)) /* formatId (4 bytes) */ if (!Stream_SafeSeek(sub1, 4)) /* formatId (4 bytes) */
goto error_out; goto error_out;
wszFormatName = (WCHAR*)Stream_Pointer(sub1); wszFormatName = Stream_ConstPointer(sub1);
rest = Stream_GetRemainingLength(sub1); rest = Stream_GetRemainingLength(sub1);
formatNameLength = _wcsnlen(wszFormatName, rest / sizeof(WCHAR)); formatNameLength = _wcsnlen(wszFormatName, rest / sizeof(WCHAR));
@ -524,7 +523,7 @@ UINT cliprdr_read_format_list(wStream* s, CLIPRDR_FORMAT_LIST* formatList, BOOL
free(format->formatName); free(format->formatName);
format->formatName = NULL; format->formatName = NULL;
wszFormatName = (WCHAR*)Stream_Pointer(sub2); wszFormatName = Stream_ConstPointer(sub2);
rest = Stream_GetRemainingLength(sub2); rest = Stream_GetRemainingLength(sub2);
formatNameLength = _wcsnlen(wszFormatName, rest / sizeof(WCHAR)); formatNameLength = _wcsnlen(wszFormatName, rest / sizeof(WCHAR));
if (!Stream_SafeSeek(sub2, (formatNameLength + 1) * sizeof(WCHAR))) if (!Stream_SafeSeek(sub2, (formatNameLength + 1) * sizeof(WCHAR)))

13
channels/cliprdr/server/cliprdr_main.c
View File

@ -596,7 +596,6 @@ static UINT cliprdr_server_receive_temporary_directory(CliprdrServerContext* con
const CLIPRDR_HEADER* header) const CLIPRDR_HEADER* header)
{ {
size_t length; size_t length;
const WCHAR* wszTempDir;
CLIPRDR_TEMP_DIRECTORY tempDirectory = { 0 }; CLIPRDR_TEMP_DIRECTORY tempDirectory = { 0 };
CliprdrServerPrivate* cliprdr; CliprdrServerPrivate* cliprdr;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
@ -611,7 +610,7 @@ static UINT cliprdr_server_receive_temporary_directory(CliprdrServerContext* con
ARRAYSIZE(cliprdr->temporaryDirectory) * sizeof(WCHAR))) ARRAYSIZE(cliprdr->temporaryDirectory) * sizeof(WCHAR)))
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
wszTempDir = (WCHAR*)Stream_Pointer(s); const WCHAR* wszTempDir = Stream_ConstPointer(s);
if (wszTempDir[ARRAYSIZE(cliprdr->temporaryDirectory) - 1] != 0) if (wszTempDir[ARRAYSIZE(cliprdr->temporaryDirectory) - 1] != 0)
{ {
@ -1102,7 +1101,7 @@ static UINT cliprdr_server_read(CliprdrServerContext* context)
if (status == WAIT_TIMEOUT) if (status == WAIT_TIMEOUT)
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, (PCHAR)Stream_Pointer(s), BytesToRead, if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
&BytesReturned)) &BytesReturned))
{ {
WLog_ERR(TAG, "WTSVirtualChannelRead failed!"); WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
@ -1145,8 +1144,8 @@ static UINT cliprdr_server_read(CliprdrServerContext* context)
if (status == WAIT_TIMEOUT) if (status == WAIT_TIMEOUT)
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
BytesToRead, &BytesReturned)) &BytesReturned))
{ {
WLog_ERR(TAG, "WTSVirtualChannelRead failed!"); WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
return ERROR_INTERNAL_ERROR; return ERROR_INTERNAL_ERROR;
@ -1185,8 +1184,8 @@ static UINT cliprdr_server_read(CliprdrServerContext* context)
BytesReturned = 0; BytesReturned = 0;
BytesToRead = 4; BytesToRead = 4;
if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(cliprdr->ChannelHandle, 0, Stream_Pointer(s), BytesToRead,
BytesToRead, &BytesReturned)) &BytesReturned))
{ {
WLog_ERR(TAG, "WTSVirtualChannelRead failed!"); WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
return ERROR_INTERNAL_ERROR; return ERROR_INTERNAL_ERROR;

12
channels/drdynvc/client/drdynvc_main.c
View File

@ -1146,13 +1146,9 @@ static UINT32 drdynvc_read_variable_uint(wStream* s, int cbLen)
*/ */
static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s) static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
{ {
size_t pos;
UINT status; UINT status;
UINT32 ChannelId;
wStream* data_out; wStream* data_out;
UINT channel_status; UINT channel_status;
char* name;
size_t length;
DVCMAN* dvcman; DVCMAN* dvcman;
DVCMAN_CHANNEL* channel; DVCMAN_CHANNEL* channel;
UINT32 retStatus; UINT32 retStatus;
@ -1185,10 +1181,10 @@ static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int c
if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId))) if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
ChannelId = drdynvc_read_variable_uint(s, cbChId); const UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
pos = Stream_GetPosition(s); const size_t pos = Stream_GetPosition(s);
name = (char*)Stream_Pointer(s); const char* name = Stream_ConstPointer(s);
length = Stream_GetRemainingLength(s); const size_t length = Stream_GetRemainingLength(s);
if (strnlen(name, length) >= length) if (strnlen(name, length) >= length)
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;

4
channels/drive/client/drive_file.c
View File

@ -465,7 +465,7 @@ BOOL drive_file_read(DRIVE_FILE* file, BYTE* buffer, UINT32* Length)
return FALSE; return FALSE;
} }
BOOL drive_file_write(DRIVE_FILE* file, BYTE* buffer, UINT32 Length) BOOL drive_file_write(DRIVE_FILE* file, const BYTE* buffer, UINT32 Length)
{ {
DWORD written; DWORD written;
@ -823,7 +823,7 @@ BOOL drive_file_set_information(DRIVE_FILE* file, UINT32 FsInformationClass, UIN
if (!Stream_CheckAndLogRequiredLength(TAG, input, FileNameLength)) if (!Stream_CheckAndLogRequiredLength(TAG, input, FileNameLength))
return FALSE; return FALSE;
fullpath = drive_file_combine_fullpath(file->basepath, (WCHAR*)Stream_Pointer(input), fullpath = drive_file_combine_fullpath(file->basepath, Stream_ConstPointer(input),
FileNameLength / sizeof(WCHAR)); FileNameLength / sizeof(WCHAR));
if (!fullpath) if (!fullpath)

2
channels/drive/client/drive_file.h
View File

@ -57,7 +57,7 @@ BOOL drive_file_free(DRIVE_FILE* file);
BOOL drive_file_open(DRIVE_FILE* file); BOOL drive_file_open(DRIVE_FILE* file);
BOOL drive_file_seek(DRIVE_FILE* file, UINT64 Offset); BOOL drive_file_seek(DRIVE_FILE* file, UINT64 Offset);
BOOL drive_file_read(DRIVE_FILE* file, BYTE* buffer, UINT32* Length); BOOL drive_file_read(DRIVE_FILE* file, BYTE* buffer, UINT32* Length);
BOOL drive_file_write(DRIVE_FILE* file, BYTE* buffer, UINT32 Length); BOOL drive_file_write(DRIVE_FILE* file, const BYTE* buffer, UINT32 Length);
BOOL drive_file_query_information(DRIVE_FILE* file, UINT32 FsInformationClass, wStream* output); BOOL drive_file_query_information(DRIVE_FILE* file, UINT32 FsInformationClass, wStream* output);
BOOL drive_file_set_information(DRIVE_FILE* file, UINT32 FsInformationClass, UINT32 Length, BOOL drive_file_set_information(DRIVE_FILE* file, UINT32 FsInformationClass, UINT32 Length,
wStream* input); wStream* input);

9
channels/drive/client/drive_main.c
View File

@ -178,7 +178,7 @@ static UINT drive_process_irp_create(DRIVE_DEVICE* drive, IRP* irp)
if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, PathLength)) if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, PathLength))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
path = (const WCHAR*)Stream_Pointer(irp->input); path = Stream_ConstPointer(irp->input);
FileId = irp->devman->id_sequence++; FileId = irp->devman->id_sequence++;
file = drive_file_new(drive->path, path, PathLength / sizeof(WCHAR), FileId, DesiredAccess, file = drive_file_new(drive->path, path, PathLength / sizeof(WCHAR), FileId, DesiredAccess,
CreateDisposition, CreateOptions, FileAttributes, SharedAccess); CreateDisposition, CreateOptions, FileAttributes, SharedAccess);
@ -300,7 +300,7 @@ static UINT drive_process_irp_read(DRIVE_DEVICE* drive, IRP* irp)
Stream_Write_UINT32(irp->output, 0); Stream_Write_UINT32(irp->output, 0);
else else
{ {
BYTE* buffer = Stream_Pointer(irp->output) + sizeof(UINT32); BYTE* buffer = Stream_PointerAs(irp->output, BYTE) + sizeof(UINT32);
if (!drive_file_read(file, buffer, &Length)) if (!drive_file_read(file, buffer, &Length))
{ {
@ -327,7 +327,6 @@ static UINT drive_process_irp_write(DRIVE_DEVICE* drive, IRP* irp)
DRIVE_FILE* file; DRIVE_FILE* file;
UINT32 Length; UINT32 Length;
UINT64 Offset; UINT64 Offset;
void* ptr;
if (!drive || !irp || !irp->input || !irp->output || !irp->Complete) if (!drive || !irp || !irp->input || !irp->output || !irp->Complete)
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
@ -338,7 +337,7 @@ static UINT drive_process_irp_write(DRIVE_DEVICE* drive, IRP* irp)
Stream_Read_UINT32(irp->input, Length); Stream_Read_UINT32(irp->input, Length);
Stream_Read_UINT64(irp->input, Offset); Stream_Read_UINT64(irp->input, Offset);
Stream_Seek(irp->input, 20); /* Padding */ Stream_Seek(irp->input, 20); /* Padding */
ptr = Stream_Pointer(irp->input); const void* ptr = Stream_ConstPointer(irp->input);
if (!Stream_SafeSeek(irp->input, Length)) if (!Stream_SafeSeek(irp->input, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
file = drive_get_file_by_id(drive, irp->FileId); file = drive_get_file_by_id(drive, irp->FileId);
@ -611,7 +610,7 @@ static UINT drive_process_irp_query_directory(DRIVE_DEVICE* drive, IRP* irp)
Stream_Read_UINT8(irp->input, InitialQuery); Stream_Read_UINT8(irp->input, InitialQuery);
Stream_Read_UINT32(irp->input, PathLength); Stream_Read_UINT32(irp->input, PathLength);
Stream_Seek(irp->input, 23); /* Padding */ Stream_Seek(irp->input, 23); /* Padding */
path = (WCHAR*)Stream_Pointer(irp->input); path = Stream_ConstPointer(irp->input);
if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, PathLength)) if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, PathLength))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;

2
channels/echo/client/echo_main.c
View File

@ -47,7 +47,7 @@ typedef struct
static UINT echo_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data) static UINT echo_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
{ {
GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback; GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
BYTE* pBuffer = Stream_Pointer(data); const BYTE* pBuffer = Stream_ConstPointer(data);
UINT32 cbSize = Stream_GetRemainingLength(data); UINT32 cbSize = Stream_GetRemainingLength(data);
/* echo back what we have received. ECHO does not have any message IDs. */ /* echo back what we have received. ECHO does not have any message IDs. */

7
channels/parallel/client/parallel_main.c
View File

@ -77,7 +77,6 @@ typedef struct
static UINT parallel_process_irp_create(PARALLEL_DEVICE* parallel, IRP* irp) static UINT parallel_process_irp_create(PARALLEL_DEVICE* parallel, IRP* irp)
{ {
char* path = NULL; char* path = NULL;
WCHAR* ptr;
UINT32 PathLength; UINT32 PathLength;
if (!Stream_SafeSeek(irp->input, 28)) if (!Stream_SafeSeek(irp->input, 28))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -88,7 +87,7 @@ static UINT parallel_process_irp_create(PARALLEL_DEVICE* parallel, IRP* irp)
Stream_Read_UINT32(irp->input, PathLength); Stream_Read_UINT32(irp->input, PathLength);
if (PathLength < sizeof(WCHAR)) if (PathLength < sizeof(WCHAR))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
ptr = (WCHAR*)Stream_Pointer(irp->input); const WCHAR* ptr = Stream_ConstPointer(irp->input);
if (!Stream_SafeSeek(irp->input, PathLength)) if (!Stream_SafeSeek(irp->input, PathLength))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
path = ConvertWCharNToUtf8Alloc(ptr, PathLength / sizeof(WCHAR), NULL); path = ConvertWCharNToUtf8Alloc(ptr, PathLength / sizeof(WCHAR), NULL);
@ -201,7 +200,7 @@ static UINT parallel_process_irp_write(PARALLEL_DEVICE* parallel, IRP* irp)
UINT32 Length; UINT32 Length;
UINT64 Offset; UINT64 Offset;
ssize_t status; ssize_t status;
void* ptr;
if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, 12)) if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, 12))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -209,7 +208,7 @@ static UINT parallel_process_irp_write(PARALLEL_DEVICE* parallel, IRP* irp)
Stream_Read_UINT64(irp->input, Offset); Stream_Read_UINT64(irp->input, Offset);
if (!Stream_SafeSeek(irp->input, 20)) /* Padding */ if (!Stream_SafeSeek(irp->input, 20)) /* Padding */
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
ptr = Stream_Pointer(irp->input); const void* ptr = Stream_ConstPointer(irp->input);
if (!Stream_SafeSeek(irp->input, Length)) if (!Stream_SafeSeek(irp->input, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
len = Length; len = Length;

21
channels/printer/client/printer_main.c
View File

@ -497,7 +497,6 @@ static UINT printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp)
UINT64 Offset; UINT64 Offset;
rdpPrintJob* printjob = NULL; rdpPrintJob* printjob = NULL;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
void* ptr;
WINPR_ASSERT(printer_dev); WINPR_ASSERT(printer_dev);
WINPR_ASSERT(irp); WINPR_ASSERT(irp);
@ -507,7 +506,7 @@ static UINT printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp)
Stream_Read_UINT32(irp->input, Length); Stream_Read_UINT32(irp->input, Length);
Stream_Read_UINT64(irp->input, Offset); Stream_Read_UINT64(irp->input, Offset);
Stream_Seek(irp->input, 20); /* Padding */ Stream_Seek(irp->input, 20); /* Padding */
ptr = Stream_Pointer(irp->input); const void* ptr = Stream_ConstPointer(irp->input);
if (!Stream_SafeSeek(irp->input, Length)) if (!Stream_SafeSeek(irp->input, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
if (printer_dev->printer) if (printer_dev->printer)
@ -724,25 +723,25 @@ static UINT printer_custom_component(DEVICE* device, UINT16 component, UINT16 pa
if (!Stream_CheckAndLogRequiredLength(TAG, s, PnPNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, PnPNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
PnPName = (const WCHAR*)Stream_Pointer(s); PnPName = Stream_ConstPointer(s);
Stream_Seek(s, PnPNameLen); Stream_Seek(s, PnPNameLen);
if (!Stream_CheckAndLogRequiredLength(TAG, s, DriverNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, DriverNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
DriverName = (const WCHAR*)Stream_Pointer(s); DriverName = Stream_ConstPointer(s);
Stream_Seek(s, DriverNameLen); Stream_Seek(s, DriverNameLen);
if (!Stream_CheckAndLogRequiredLength(TAG, s, PrintNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, PrintNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
PrinterName = (const WCHAR*)Stream_Pointer(s); PrinterName = Stream_ConstPointer(s);
Stream_Seek(s, PrintNameLen); Stream_Seek(s, PrintNameLen);
if (!Stream_CheckAndLogRequiredLength(TAG, s, CacheFieldsLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, CacheFieldsLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
CachedPrinterConfigData = Stream_Pointer(s); CachedPrinterConfigData = Stream_ConstPointer(s);
Stream_Seek(s, CacheFieldsLen); Stream_Seek(s, CacheFieldsLen);
if (!printer_save_to_config(settings, PortDosName, sizeof(PortDosName), PnPName, if (!printer_save_to_config(settings, PortDosName, sizeof(PortDosName), PnPName,
@ -768,13 +767,13 @@ static UINT printer_custom_component(DEVICE* device, UINT16 component, UINT16 pa
if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
PrinterName = (const WCHAR*)Stream_Pointer(s); PrinterName = Stream_ConstPointer(s);
Stream_Seek(s, PrinterNameLen); Stream_Seek(s, PrinterNameLen);
if (!Stream_CheckAndLogRequiredLength(TAG, s, ConfigDataLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, ConfigDataLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
ConfigData = Stream_Pointer(s); ConfigData = Stream_ConstPointer(s);
Stream_Seek(s, ConfigDataLen); Stream_Seek(s, ConfigDataLen);
if (!printer_update_to_config(settings, PrinterName, PrinterNameLen, ConfigData, if (!printer_update_to_config(settings, PrinterName, PrinterNameLen, ConfigData,
@ -796,7 +795,7 @@ static UINT printer_custom_component(DEVICE* device, UINT16 component, UINT16 pa
if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
PrinterName = (const WCHAR*)Stream_Pointer(s); PrinterName = Stream_ConstPointer(s);
Stream_Seek(s, PrinterNameLen); Stream_Seek(s, PrinterNameLen);
printer_remove_config(settings, PrinterName, PrinterNameLen); printer_remove_config(settings, PrinterName, PrinterNameLen);
} }
@ -817,13 +816,13 @@ static UINT printer_custom_component(DEVICE* device, UINT16 component, UINT16 pa
if (!Stream_CheckAndLogRequiredLength(TAG, s, OldPrinterNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, OldPrinterNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
OldPrinterName = (const WCHAR*)Stream_Pointer(s); OldPrinterName = Stream_ConstPointer(s);
Stream_Seek(s, OldPrinterNameLen); Stream_Seek(s, OldPrinterNameLen);
if (!Stream_CheckAndLogRequiredLength(TAG, s, NewPrinterNameLen)) if (!Stream_CheckAndLogRequiredLength(TAG, s, NewPrinterNameLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
NewPrinterName = (const WCHAR*)Stream_Pointer(s); NewPrinterName = Stream_ConstPointer(s);
Stream_Seek(s, NewPrinterNameLen); Stream_Seek(s, NewPrinterNameLen);
if (!printer_move_config(settings, OldPrinterName, OldPrinterNameLen, if (!printer_move_config(settings, OldPrinterName, OldPrinterNameLen,

6
channels/rail/server/rail_main.c
View File

@ -1582,8 +1582,8 @@ UINT rail_server_handle_messages(RailServerContext* context)
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
} }
if (!WTSVirtualChannelRead(priv->rail_channel, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(priv->rail_channel, 0, Stream_Pointer(s), RAIL_PDU_HEADER_LENGTH,
RAIL_PDU_HEADER_LENGTH, &bytesReturned)) &bytesReturned))
{ {
if (GetLastError() == ERROR_NO_DATA) if (GetLastError() == ERROR_NO_DATA)
return ERROR_NO_DATA; return ERROR_NO_DATA;
@ -1607,7 +1607,7 @@ UINT rail_server_handle_messages(RailServerContext* context)
} }
/* Read body */ /* Read body */
if (!WTSVirtualChannelRead(priv->rail_channel, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(priv->rail_channel, 0, Stream_Pointer(s),
orderLength - RAIL_PDU_HEADER_LENGTH, &bytesReturned)) orderLength - RAIL_PDU_HEADER_LENGTH, &bytesReturned))
{ {
if (GetLastError() == ERROR_NO_DATA) if (GetLastError() == ERROR_NO_DATA)

2
channels/rdpdr/client/rdpdr_main.c
View File

@ -1335,7 +1335,7 @@ static BOOL device_announce(ULONG_PTR key, void* element, void* data)
Stream_Write_UINT32(arg->s, device->type); /* deviceType */ Stream_Write_UINT32(arg->s, device->type); /* deviceType */
Stream_Write_UINT32(arg->s, device->id); /* deviceID */ Stream_Write_UINT32(arg->s, device->id); /* deviceID */
strncpy((char*)Stream_Pointer(arg->s), device->name, 8); strncpy(Stream_Pointer(arg->s), device->name, 8);
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
{ {

31
channels/rdpdr/server/rdpdr_main.c
View File

@ -154,7 +154,7 @@ static UINT32 g_ClientId = 0;
static const WCHAR* rdpdr_read_ustring(wLog* log, wStream* s, size_t bytelen) static const WCHAR* rdpdr_read_ustring(wLog* log, wStream* s, size_t bytelen)
{ {
const size_t charlen = (bytelen + 1) / sizeof(WCHAR); const size_t charlen = (bytelen + 1) / sizeof(WCHAR);
const WCHAR* str = (const WCHAR*)Stream_Pointer(s); const WCHAR* str = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(log, s, bytelen)) if (!Stream_CheckAndLogRequiredLengthWLog(log, s, bytelen))
return NULL; return NULL;
if (_wcsnlen(str, charlen) == charlen) if (_wcsnlen(str, charlen) == charlen)
@ -358,9 +358,8 @@ static UINT rdpdr_server_receive_client_name_request(RdpdrServerContext* context
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
/* ComputerName must be null terminated, check if it really is */ /* ComputerName must be null terminated, check if it really is */
const char* computerName = Stream_ConstPointer(s);
if (Stream_Pointer(s)[ComputerNameLen - 1] || if (computerName[ComputerNameLen - 1] || (UnicodeFlag && computerName[ComputerNameLen - 2]))
(UnicodeFlag && Stream_Pointer(s)[ComputerNameLen - 2]))
{ {
WLog_Print(context->priv->log, WLOG_ERROR, "computer name must be null terminated"); WLog_Print(context->priv->log, WLOG_ERROR, "computer name must be null terminated");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -384,7 +383,7 @@ static UINT rdpdr_server_receive_client_name_request(RdpdrServerContext* context
} }
else else
{ {
const char* name = (const char*)Stream_Pointer(s); const char* name = Stream_ConstPointer(s);
context->priv->ClientComputerName = _strdup(name); context->priv->ClientComputerName = _strdup(name);
Stream_Seek(s, ComputerNameLen); Stream_Seek(s, ComputerNameLen);
@ -531,7 +530,7 @@ static UINT rdpdr_server_write_general_capability_set(RdpdrServerContext* contex
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
return error; return error;
const BYTE* data = Stream_Pointer(s); const BYTE* data = Stream_ConstPointer(s);
const size_t start = Stream_GetPosition(s); const size_t start = Stream_GetPosition(s);
Stream_Write_UINT32(s, 0); /* osType (4 bytes), ignored on receipt */ Stream_Write_UINT32(s, 0); /* osType (4 bytes), ignored on receipt */
Stream_Write_UINT32(s, 0); /* osVersion (4 bytes), unused and must be set to zero */ Stream_Write_UINT32(s, 0); /* osVersion (4 bytes), unused and must be set to zero */
@ -823,7 +822,7 @@ static UINT rdpdr_server_receive_core_capability_response(RdpdrServerContext* co
} }
status = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveCaps, context, &capabilityHeader, status = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveCaps, context, &capabilityHeader,
Stream_GetRemainingLength(s), Stream_Pointer(s)); Stream_GetRemainingLength(s), Stream_ConstPointer(s));
if (status != CHANNEL_RC_OK) if (status != CHANNEL_RC_OK)
return status; return status;
@ -1250,7 +1249,7 @@ static UINT rdpdr_server_receive_io_write_request(RdpdrServerContext* context, w
Stream_Read_UINT64(s, Offset); Stream_Read_UINT64(s, Offset);
Stream_Seek(s, 20); /* Padding */ Stream_Seek(s, 20); /* Padding */
data = Stream_Pointer(s); data = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, Length); Stream_Seek(s, Length);
@ -1282,7 +1281,7 @@ static UINT rdpdr_server_receive_io_device_control_request(RdpdrServerContext* c
Stream_Read_UINT32(s, IoControlCode); Stream_Read_UINT32(s, IoControlCode);
Stream_Seek(s, 20); /* Padding */ Stream_Seek(s, 20); /* Padding */
InputBuffer = Stream_Pointer(s); InputBuffer = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, InputBufferLength)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, InputBufferLength))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, InputBufferLength); Stream_Seek(s, InputBufferLength);
@ -1311,7 +1310,7 @@ static UINT rdpdr_server_receive_io_query_volume_information_request(RdpdrServer
Stream_Read_UINT32(s, Length); Stream_Read_UINT32(s, Length);
Stream_Seek(s, 24); /* Padding */ Stream_Seek(s, 24); /* Padding */
QueryVolumeBuffer = Stream_Pointer(s); QueryVolumeBuffer = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, Length); Stream_Seek(s, Length);
@ -1343,7 +1342,7 @@ static UINT rdpdr_server_receive_io_set_volume_information_request(RdpdrServerCo
Stream_Read_UINT32(s, Length); Stream_Read_UINT32(s, Length);
Stream_Seek(s, 24); /* Padding */ Stream_Seek(s, 24); /* Padding */
SetVolumeBuffer = Stream_Pointer(s); SetVolumeBuffer = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, Length); Stream_Seek(s, Length);
@ -1374,7 +1373,7 @@ static UINT rdpdr_server_receive_io_query_information_request(RdpdrServerContext
Stream_Read_UINT32(s, Length); Stream_Read_UINT32(s, Length);
Stream_Seek(s, 24); /* Padding */ Stream_Seek(s, 24); /* Padding */
QueryBuffer = Stream_Pointer(s); QueryBuffer = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, Length); Stream_Seek(s, Length);
@ -1405,7 +1404,7 @@ static UINT rdpdr_server_receive_io_set_information_request(RdpdrServerContext*
Stream_Read_UINT32(s, Length); Stream_Read_UINT32(s, Length);
Stream_Seek(s, 24); /* Padding */ Stream_Seek(s, 24); /* Padding */
SetBuffer = Stream_Pointer(s); SetBuffer = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, Length); Stream_Seek(s, Length);
@ -1721,7 +1720,7 @@ static UINT rdpdr_server_receive_prn_cache_add_printer(RdpdrServerContext* conte
if (!PrinterName && (PrinterNameLen > 0)) if (!PrinterName && (PrinterNameLen > 0))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
config = Stream_Pointer(s); config = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, CachedFieldsLen)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, CachedFieldsLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, CachedFieldsLen); Stream_Seek(s, CachedFieldsLen);
@ -1751,7 +1750,7 @@ static UINT rdpdr_server_receive_prn_cache_update_printer(RdpdrServerContext* co
if (!PrinterName && (PrinterNameLen > 0)) if (!PrinterName && (PrinterNameLen > 0))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
config = Stream_Pointer(s); config = Stream_ConstPointer(s);
if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, CachedFieldsLen)) if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, CachedFieldsLen))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
Stream_Seek(s, CachedFieldsLen); Stream_Seek(s, CachedFieldsLen);
@ -3008,7 +3007,7 @@ static UINT rdpdr_server_drive_read_file_callback(RdpdrServerContext* context, w
if (length > 0) if (length > 0)
{ {
buffer = (char*)Stream_Pointer(s); buffer = Stream_Pointer(s);
Stream_Seek(s, length); Stream_Seek(s, length);
} }

8
channels/rdpecam/server/camera_device_enumerator_main.c
View File

@ -164,10 +164,10 @@ static UINT enumerator_server_recv_device_added_notification(CamDevEnumServerCon
if (!Stream_CheckAndLogRequiredLength(TAG, s, 4)) if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
return ERROR_NO_DATA; return ERROR_NO_DATA;
pdu.DeviceName = (WCHAR*)Stream_Pointer(s); pdu.DeviceName = Stream_Pointer(s);
remaining_length = Stream_GetRemainingLength(s); remaining_length = Stream_GetRemainingLength(s);
channel_name_start = (WCHAR*)Stream_Pointer(s); channel_name_start = Stream_Pointer(s);
/* Search for null terminator of DeviceName */ /* Search for null terminator of DeviceName */
size_t i = 0; size_t i = 0;
@ -230,10 +230,10 @@ static UINT enumerator_server_recv_device_removed_notification(CamDevEnumServerC
if (!Stream_CheckAndLogRequiredLength(TAG, s, 2)) if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
return ERROR_NO_DATA; return ERROR_NO_DATA;
pdu.VirtualChannelName = (char*)Stream_Pointer(s); pdu.VirtualChannelName = Stream_Pointer(s);
remaining_length = Stream_GetRemainingLength(s); remaining_length = Stream_GetRemainingLength(s);
char* tmp = (char*)(Stream_Pointer(s) + 1); char* tmp = pdu.VirtualChannelName + 1;
for (size_t i = 1; i < remaining_length; ++i, ++tmp) for (size_t i = 1; i < remaining_length; ++i, ++tmp)
{ {

4
channels/rdpei/server/rdpei_main.c
View File

@ -495,8 +495,8 @@ UINT rdpei_server_handle_messages(RdpeiServerContext* context)
wStream* s = priv->inputStream; wStream* s = priv->inputStream;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
if (!WTSVirtualChannelRead(priv->channelHandle, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(priv->channelHandle, 0, Stream_Pointer(s), priv->expectedBytes,
priv->expectedBytes, &bytesReturned)) &bytesReturned))
{ {
if (GetLastError() == ERROR_NO_DATA) if (GetLastError() == ERROR_NO_DATA)
return ERROR_READ_FAULT; return ERROR_READ_FAULT;

2
channels/rdpgfx/client/rdpgfx_main.c
View File

@ -2081,7 +2081,7 @@ static UINT rdpgfx_on_data_received(IWTSVirtualChannelCallback* pChannelCallback
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
WINPR_ASSERT(gfx); WINPR_ASSERT(gfx);
status = zgfx_decompress(gfx->zgfx, Stream_Pointer(data), status = zgfx_decompress(gfx->zgfx, Stream_ConstPointer(data),
(UINT32)Stream_GetRemainingLength(data), &pDstData, &DstSize, 0); (UINT32)Stream_GetRemainingLength(data), &pDstData, &DstSize, 0);
if (status < 0) if (status < 0)

3
channels/rdpsnd/client/rdpsnd_main.c
View File

@ -598,7 +598,6 @@ static BOOL rdpsnd_detect_overrun(rdpsndPlugin* rdpsnd, const AUDIO_FORMAT* form
static UINT rdpsnd_treat_wave(rdpsndPlugin* rdpsnd, wStream* s, size_t size) static UINT rdpsnd_treat_wave(rdpsndPlugin* rdpsnd, wStream* s, size_t size)
{ {
BYTE* data;
AUDIO_FORMAT* format; AUDIO_FORMAT* format;
UINT64 end; UINT64 end;
UINT64 diffMS, ts; UINT64 diffMS, ts;
@ -620,7 +619,7 @@ static UINT rdpsnd_treat_wave(rdpsndPlugin* rdpsnd, wStream* s, size_t size)
if (error) if (error)
return error; return error;
data = Stream_Pointer(s); const BYTE* data = Stream_ConstPointer(s);
format = &rdpsnd->ClientFormats[rdpsnd->wCurrentFormatNo]; format = &rdpsnd->ClientFormats[rdpsnd->wCurrentFormatNo];
WLog_Print(rdpsnd->log, WLOG_DEBUG, WLog_Print(rdpsnd->log, WLOG_DEBUG,
"%s Wave: cBlockNo: %" PRIu8 " wTimeStamp: %" PRIu16 ", size: %" PRIdz, "%s Wave: cBlockNo: %" PRIu8 " wTimeStamp: %" PRIu16 ", size: %" PRIdz,

6
channels/rdpsnd/server/rdpsnd_main.c
View File

@ -556,7 +556,7 @@ static UINT rdpsnd_server_send_wave_pdu(RdpsndServerContext* context, UINT16 wTi
Stream_Write_UINT32(s, 0); /* bPad */ Stream_Write_UINT32(s, 0); /* bPad */
Stream_SetPosition(s, start); Stream_SetPosition(s, start);
if (!WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR)Stream_Pointer(s), end - start, if (!WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_Pointer(s), end - start,
&written)) &written))
{ {
WLog_ERR(TAG, "WTSVirtualChannelWrite failed!"); WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
@ -1144,8 +1144,8 @@ UINT rdpsnd_server_handle_messages(RdpsndServerContext* context)
priv = context->priv; priv = context->priv;
s = priv->input_stream; s = priv->input_stream;
if (!WTSVirtualChannelRead(priv->ChannelHandle, 0, (PCHAR)Stream_Pointer(s), if (!WTSVirtualChannelRead(priv->ChannelHandle, 0, Stream_Pointer(s), priv->expectedBytes,
priv->expectedBytes, &bytesReturned)) &bytesReturned))
{ {
if (GetLastError() == ERROR_NO_DATA) if (GetLastError() == ERROR_NO_DATA)
return ERROR_NO_DATA; return ERROR_NO_DATA;

2
channels/remdesk/client/remdesk_main.c
View File

@ -690,7 +690,7 @@ static UINT remdesk_process_receive(remdeskPlugin* remdesk, wStream* s)
#if 0 #if 0
WLog_DBG(TAG, "RemdeskReceive: %"PRIuz"", Stream_GetRemainingLength(s)); WLog_DBG(TAG, "RemdeskReceive: %"PRIuz"", Stream_GetRemainingLength(s));
winpr_HexDump(Stream_Pointer(s), Stream_GetRemainingLength(s)); winpr_HexDump(Stream_ConstPointer(s), Stream_GetRemainingLength(s));
#endif #endif
if ((status = remdesk_read_channel_header(s, &header))) if ((status = remdesk_read_channel_header(s, &header)))

36
channels/remdesk/server/remdesk_main.c
View File

@ -257,17 +257,13 @@ static UINT remdesk_recv_ctl_version_info_pdu(RemdeskServerContext* context, wSt
static UINT remdesk_recv_ctl_remote_control_desktop_pdu(RemdeskServerContext* context, wStream* s, static UINT remdesk_recv_ctl_remote_control_desktop_pdu(RemdeskServerContext* context, wStream* s,
REMDESK_CHANNEL_HEADER* header) REMDESK_CHANNEL_HEADER* header)
{ {
SSIZE_T cchStringW; SSIZE_T cchStringW = 0;
WCHAR* pStringW;
UINT32 msgLength;
SSIZE_T cbRaConnectionStringW = 0; SSIZE_T cbRaConnectionStringW = 0;
WCHAR* raConnectionStringW = NULL; REMDESK_CTL_REMOTE_CONTROL_DESKTOP_PDU pdu = { 0 };
REMDESK_CTL_REMOTE_CONTROL_DESKTOP_PDU pdu; UINT error = 0;
UINT error; UINT32 msgLength = header->DataLength - 4;
msgLength = header->DataLength - 4; const WCHAR* pStringW = Stream_ConstPointer(s);
pStringW = (WCHAR*)Stream_Pointer(s); const WCHAR* raConnectionStringW = pStringW;
raConnectionStringW = pStringW;
cchStringW = 0;
while ((msgLength > 0) && pStringW[cchStringW]) while ((msgLength > 0) && pStringW[cchStringW])
{ {
@ -302,18 +298,15 @@ static UINT remdesk_recv_ctl_remote_control_desktop_pdu(RemdeskServerContext* co
static UINT remdesk_recv_ctl_authenticate_pdu(RemdeskServerContext* context, wStream* s, static UINT remdesk_recv_ctl_authenticate_pdu(RemdeskServerContext* context, wStream* s,
REMDESK_CHANNEL_HEADER* header) REMDESK_CHANNEL_HEADER* header)
{ {
int cchStringW; int cchStringW = 0;
WCHAR* pStringW; UINT32 msgLength = 0;
UINT32 msgLength;
int cbExpertBlobW = 0; int cbExpertBlobW = 0;
WCHAR* expertBlobW = NULL; const WCHAR* expertBlobW = NULL;
int cbRaConnectionStringW = 0; int cbRaConnectionStringW = 0;
WCHAR* raConnectionStringW = NULL; REMDESK_CTL_AUTHENTICATE_PDU pdu = { 0 };
REMDESK_CTL_AUTHENTICATE_PDU pdu;
msgLength = header->DataLength - 4; msgLength = header->DataLength - 4;
pStringW = (WCHAR*)Stream_Pointer(s); const WCHAR* pStringW = Stream_ConstPointer(s);
raConnectionStringW = pStringW; const WCHAR* raConnectionStringW = pStringW;
cchStringW = 0;
while ((msgLength > 0) && pStringW[cchStringW]) while ((msgLength > 0) && pStringW[cchStringW])
{ {
@ -368,14 +361,13 @@ static UINT remdesk_recv_ctl_verify_password_pdu(RemdeskServerContext* context,
REMDESK_CHANNEL_HEADER* header) REMDESK_CHANNEL_HEADER* header)
{ {
SSIZE_T cbExpertBlobW = 0; SSIZE_T cbExpertBlobW = 0;
WCHAR* expertBlobW = NULL;
REMDESK_CTL_VERIFY_PASSWORD_PDU pdu; REMDESK_CTL_VERIFY_PASSWORD_PDU pdu;
UINT error; UINT error;
if (!Stream_CheckAndLogRequiredLength(TAG, s, 8)) if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
expertBlobW = (WCHAR*)Stream_Pointer(s); const WCHAR* expertBlobW = Stream_ConstPointer(s);
cbExpertBlobW = header->DataLength - 4; cbExpertBlobW = header->DataLength - 4;
pdu.expertBlob = ConvertWCharNToUtf8Alloc(expertBlobW, cbExpertBlobW / sizeof(WCHAR), NULL); pdu.expertBlob = ConvertWCharNToUtf8Alloc(expertBlobW, cbExpertBlobW / sizeof(WCHAR), NULL);
@ -489,7 +481,7 @@ static UINT remdesk_server_receive_pdu(RemdeskServerContext* context, wStream* s
REMDESK_CHANNEL_HEADER header; REMDESK_CHANNEL_HEADER header;
#if 0 #if 0
WLog_INFO(TAG, "RemdeskReceive: %"PRIuz"", Stream_GetRemainingLength(s)); WLog_INFO(TAG, "RemdeskReceive: %"PRIuz"", Stream_GetRemainingLength(s));
winpr_HexDump(Stream_Pointer(s), Stream_GetRemainingLength(s)); winpr_HexDump(WCHAR* expertBlobW = NULL;(s), Stream_GetRemainingLength(s));
#endif #endif
if ((error = remdesk_read_channel_header(s, &header))) if ((error = remdesk_read_channel_header(s, &header)))

3
channels/serial/client/serial_main.c
View File

@ -294,7 +294,6 @@ static UINT serial_process_irp_write(SERIAL_DEVICE* serial, IRP* irp)
{ {
UINT32 Length; UINT32 Length;
UINT64 Offset; UINT64 Offset;
void* ptr;
DWORD nbWritten = 0; DWORD nbWritten = 0;
if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, 32)) if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, 32))
@ -314,7 +313,7 @@ static UINT serial_process_irp_write(SERIAL_DEVICE* serial, IRP* irp)
WLog_Print(serial->log, WLOG_DEBUG, "writing %" PRIu32 " bytes to %s", Length, WLog_Print(serial->log, WLOG_DEBUG, "writing %" PRIu32 " bytes to %s", Length,
serial->device.name); serial->device.name);
ptr = Stream_Pointer(irp->input); const void* ptr = Stream_ConstPointer(irp->input);
if (!Stream_SafeSeek(irp->input, Length)) if (!Stream_SafeSeek(irp->input, Length))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
/* FIXME: CommWriteFile to be replaced by WriteFile */ /* FIXME: CommWriteFile to be replaced by WriteFile */

8
client/Wayland/wlf_cliprdr.c
View File

@ -383,16 +383,16 @@ static UINT wlf_cliprdr_send_client_capabilities(wfClipboard* clipboard)
{ {
WINPR_ASSERT(clipboard); WINPR_ASSERT(clipboard);
const CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = { CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = {
.capabilitySetType = CB_CAPSTYPE_GENERAL, .capabilitySetType = CB_CAPSTYPE_GENERAL,
.capabilitySetLength = 12, .capabilitySetLength = 12,
.version = CB_CAPS_VERSION_2, .version = CB_CAPS_VERSION_2,
.generalFlags = .generalFlags =
CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(clipboard->file) CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(clipboard->file)
}; };
const CLIPRDR_CAPABILITIES capabilities = { CLIPRDR_CAPABILITIES capabilities = { .cCapabilitiesSets = 1,
.cCapabilitiesSets = 1, .capabilitySets = (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet) .capabilitySets =
}; (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet) };
WINPR_ASSERT(clipboard); WINPR_ASSERT(clipboard);
WINPR_ASSERT(clipboard->context); WINPR_ASSERT(clipboard->context);

4
client/X11/xf_window.c
View File

@ -443,9 +443,9 @@ void xf_SetWindowDecorations(xfContext* xfc, Window window, BOOL show)
void xf_SetWindowUnlisted(xfContext* xfc, Window window) void xf_SetWindowUnlisted(xfContext* xfc, Window window)
{ {
WINPR_ASSERT(xfc); WINPR_ASSERT(xfc);
const Atom window_state[] = { xfc->_NET_WM_STATE_SKIP_PAGER, xfc->_NET_WM_STATE_SKIP_TASKBAR }; Atom window_state[] = { xfc->_NET_WM_STATE_SKIP_PAGER, xfc->_NET_WM_STATE_SKIP_TASKBAR };
LogTagAndXChangeProperty(TAG, xfc->display, window, xfc->_NET_WM_STATE, XA_ATOM, 32, LogTagAndXChangeProperty(TAG, xfc->display, window, xfc->_NET_WM_STATE, XA_ATOM, 32,
PropModeReplace, (BYTE*)&window_state, 2); PropModeReplace, (BYTE*)window_state, 2);
} }
static void xf_SetWindowPID(xfContext* xfc, Window window, pid_t pid) static void xf_SetWindowPID(xfContext* xfc, Window window, pid_t pid)

2
libfreerdp/core/aad.c
View File

@ -94,7 +94,7 @@ static int BIO_get_line(BIO* bio, char* buf, int size)
} }
#endif #endif
static const char* auth_server = "login.microsoftonline.com"; static char* auth_server = "login.microsoftonline.com";
static const char nonce_http_request[] = "" static const char nonce_http_request[] = ""
"POST /common/oauth2/token HTTP/1.1\r\n" "POST /common/oauth2/token HTTP/1.1\r\n"

2
libfreerdp/core/connection.c
View File

@ -897,7 +897,7 @@ BOOL rdp_server_establish_keys(rdpRdp* rdp, wStream* s)
if (!Stream_CheckAndLogRequiredLength(TAG, s, rand_len)) if (!Stream_CheckAndLogRequiredLength(TAG, s, rand_len))
return FALSE; return FALSE;
const BYTE* crypt_random = Stream_Pointer(s); const BYTE* crypt_random = Stream_ConstPointer(s);
if (!Stream_SafeSeek(s, rand_len)) if (!Stream_SafeSeek(s, rand_len))
goto end; goto end;
if (!rdp_update_client_random(rdp->settings, crypt_random, rand_len)) if (!rdp_update_client_random(rdp->settings, crypt_random, rand_len))

4
libfreerdp/core/fastpath.c
View File

@ -981,7 +981,7 @@ BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s, size_t
goto fail; goto fail;
int sec_bytes = fastpath_get_sec_bytes(fastpath->rdp); int sec_bytes = fastpath_get_sec_bytes(fastpath->rdp);
BYTE* fpInputEvents = Stream_Pointer(s) + sec_bytes; BYTE* fpInputEvents = Stream_PointerAs(s, BYTE) + sec_bytes;
UINT16 fpInputEvents_length = length - 3 - sec_bytes; UINT16 fpInputEvents_length = length - 3 - sec_bytes;
WINPR_ASSERT(rdp->settings); WINPR_ASSERT(rdp->settings);
@ -1232,7 +1232,7 @@ BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s
if (!security_lock(rdp)) if (!security_lock(rdp))
return FALSE; return FALSE;
UINT32 dataSize = fpUpdateHeaderSize + DstSize + pad; UINT32 dataSize = fpUpdateHeaderSize + DstSize + pad;
BYTE* data = Stream_Pointer(fs) - dataSize; BYTE* data = Stream_PointerAs(fs, BYTE) - dataSize;
if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS) if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
{ {

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

@ -312,7 +312,6 @@ static const char* capabilities_enum_to_string(UINT32 capabilities)
static BOOL rdg_read_http_unicode_string(wStream* s, const WCHAR** string, UINT16* lengthInBytes) static BOOL rdg_read_http_unicode_string(wStream* s, const WCHAR** string, UINT16* lengthInBytes)
{ {
WCHAR* str;
UINT16 strLenBytes; UINT16 strLenBytes;
size_t rem = Stream_GetRemainingLength(s); size_t rem = Stream_GetRemainingLength(s);
@ -325,7 +324,7 @@ static BOOL rdg_read_http_unicode_string(wStream* s, const WCHAR** string, UINT1
Stream_Read_UINT16(s, strLenBytes); Stream_Read_UINT16(s, strLenBytes);
/* Remember position of our string */ /* Remember position of our string */
str = (WCHAR*)Stream_Pointer(s); const WCHAR* str = Stream_ConstPointer(s);
/* seek past the string - if this fails something is wrong */ /* seek past the string - if this fails something is wrong */
if (!Stream_SafeSeek(s, strLenBytes)) if (!Stream_SafeSeek(s, strLenBytes))

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

@ -320,7 +320,7 @@ fail:
BOOL rpc_recv_bind_ack_pdu(rdpRpc* rpc, wStream* s) BOOL rpc_recv_bind_ack_pdu(rdpRpc* rpc, wStream* s)
{ {
BOOL rc = FALSE; BOOL rc = FALSE;
BYTE* auth_data; const BYTE* auth_data;
size_t pos, end; size_t pos, end;
rpcconn_hdr_t header = { 0 }; rpcconn_hdr_t header = { 0 };
SecBuffer buffer = { 0 }; SecBuffer buffer = { 0 };
@ -343,7 +343,7 @@ BOOL rpc_recv_bind_ack_pdu(rdpRpc* rpc, wStream* s)
* rts_read_pdu_header did already do consistency checks */ * rts_read_pdu_header did already do consistency checks */
end = Stream_GetPosition(s); end = Stream_GetPosition(s);
Stream_SetPosition(s, pos + header.common.frag_length - header.common.auth_length); Stream_SetPosition(s, pos + header.common.frag_length - header.common.auth_length);
auth_data = Stream_Pointer(s); auth_data = Stream_ConstPointer(s);
Stream_SetPosition(s, end); Stream_SetPosition(s, end);
buffer.cbBuffer = header.common.auth_length; buffer.cbBuffer = header.common.auth_length;

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

@ -417,7 +417,7 @@ static int rpc_client_recv_fragment(rdpRpc* rpc, wStream* fragment)
goto fail; goto fail;
Stream_SetPosition(fragment, StubOffset); Stream_SetPosition(fragment, StubOffset);
Stream_Write(pdu->s, Stream_Pointer(fragment), StubLength); Stream_Write(pdu->s, Stream_ConstPointer(fragment), StubLength);
rpc->StubFragCount++; rpc->StubFragCount++;
if (response->alloc_hint == StubLength) if (response->alloc_hint == StubLength)
@ -439,7 +439,7 @@ static int rpc_client_recv_fragment(rdpRpc* rpc, wStream* fragment)
if (Stream_Length(fragment) < StubOffset + StubLength) if (Stream_Length(fragment) < StubOffset + StubLength)
goto fail; goto fail;
Stream_SetPosition(fragment, StubOffset); Stream_SetPosition(fragment, StubOffset);
rpc_client_receive_pipe_write(rpc->client, Stream_Pointer(fragment), rpc_client_receive_pipe_write(rpc->client, Stream_ConstPointer(fragment),
(size_t)StubLength); (size_t)StubLength);
rpc->StubFragCount++; rpc->StubFragCount++;

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

@ -446,8 +446,6 @@ static BOOL rts_read_supported_versions(wStream* s, p_rt_versions_supported_t* v
static BOOL rts_read_port_any(wStream* s, port_any_t* port) static BOOL rts_read_port_any(wStream* s, port_any_t* port)
{ {
const void* ptr;
WINPR_ASSERT(s); WINPR_ASSERT(s);
WINPR_ASSERT(port); WINPR_ASSERT(port);
@ -458,7 +456,7 @@ static BOOL rts_read_port_any(wStream* s, port_any_t* port)
if (port->length == 0) if (port->length == 0)
return TRUE; return TRUE;
ptr = Stream_Pointer(s); const void* ptr = Stream_ConstPointer(s);
if (!Stream_SafeSeek(s, port->length)) if (!Stream_SafeSeek(s, port->length))
return FALSE; return FALSE;
port->port_spec = sdup(ptr, port->length); port->port_spec = sdup(ptr, port->length);

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

@ -1205,7 +1205,7 @@ static BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg, RPC_PDU* pdu,
goto fail; goto fail;
} }
packetStringMessage.msgBuffer = (WCHAR*)Stream_Pointer(pdu->s); packetStringMessage.msgBuffer = Stream_Pointer(pdu->s);
if (!Stream_CheckAndLogRequiredLength(TAG, pdu->s, packetStringMessage.msgBytes)) if (!Stream_CheckAndLogRequiredLength(TAG, pdu->s, packetStringMessage.msgBytes))
goto fail; goto fail;
@ -1593,7 +1593,7 @@ static BOOL TsProxyReadPacketSTringMessage(rdpTsg* tsg, wStream* s, TSG_PACKET_S
if (!Stream_CheckAndLogRequiredLength(TAG, s, msg->msgBytes)) if (!Stream_CheckAndLogRequiredLength(TAG, s, msg->msgBytes))
return FALSE; return FALSE;
msg->msgBuffer = (WCHAR*)Stream_Pointer(s); msg->msgBuffer = Stream_Pointer(s);
Stream_Seek(s, msg->msgBytes); Stream_Seek(s, msg->msgBytes);
return TRUE; return TRUE;

6
libfreerdp/core/info.c
View File

@ -108,7 +108,7 @@ static BOOL rdp_read_info_null_string(const char* what, UINT32 flags, wStream* s
} }
else else
{ {
const char* domain = (const char*)Stream_Pointer(s); const char* domain = Stream_ConstPointer(s);
if (!Stream_SafeSeek(s, cbLen)) if (!Stream_SafeSeek(s, cbLen))
{ {
WLog_ERR(TAG, "protocol error: no data to read for %s [expected %" PRIuz "]", what, WLog_ERR(TAG, "protocol error: no data to read for %s [expected %" PRIuz "]", what,
@ -1068,7 +1068,7 @@ static BOOL rdp_info_read_string(const char* what, wStream* s, size_t size, size
return FALSE; return FALSE;
} }
const WCHAR* str = Stream_Pointer(s); const WCHAR* str = Stream_ConstPointer(s);
if (str[size / sizeof(WCHAR) - 1]) if (str[size / sizeof(WCHAR) - 1])
{ {
WLog_ERR(TAG, "protocol error: %s must be null terminated", what); WLog_ERR(TAG, "protocol error: %s must be null terminated", what);
@ -1200,7 +1200,7 @@ static BOOL rdp_recv_logon_info_v2(rdpRdp* rdp, wStream* s, logon_info* info)
if (rem > 0) if (rem > 0)
{ {
BOOL warn = FALSE; BOOL warn = FALSE;
const char* str = Stream_Pointer(s); const char* str = Stream_ConstPointer(s);
for (size_t x = 0; x < rem; x++) for (size_t x = 0; x < rem; x++)
{ {
if (str[x] != '\0') if (str[x] != '\0')

2
libfreerdp/core/multitransport.c
View File

@ -68,7 +68,7 @@ state_run_t multitransport_recv_request(rdpMultitransport* multi, wStream* s)
Stream_Read_UINT32(s, requestId); /* requestId (4 bytes) */ Stream_Read_UINT32(s, requestId); /* requestId (4 bytes) */
Stream_Read_UINT16(s, requestedProto); /* requestedProtocol (2 bytes) */ Stream_Read_UINT16(s, requestedProto); /* requestedProtocol (2 bytes) */
Stream_Seek(s, 2); /* reserved (2 bytes) */ Stream_Seek(s, 2); /* reserved (2 bytes) */
cookie = Stream_Pointer(s); cookie = Stream_ConstPointer(s);
Stream_Seek(s, RDPUDP_COOKIE_LEN); /* securityCookie (16 bytes) */ Stream_Seek(s, RDPUDP_COOKIE_LEN); /* securityCookie (16 bytes) */
WINPR_ASSERT(multi->MtRequest); WINPR_ASSERT(multi->MtRequest);

15
libfreerdp/core/nego.c
View File

@ -882,25 +882,24 @@ static BOOL nego_read_request_token_or_cookie(rdpNego* nego, wStream* s)
* string terminated by a 0x0D0A two-byte sequence: * string terminated by a 0x0D0A two-byte sequence:
* Cookie:[space]mstshash=[ANSISTRING][\x0D\x0A] * Cookie:[space]mstshash=[ANSISTRING][\x0D\x0A]
*/ */
BYTE* str = NULL;
UINT16 crlf = 0; UINT16 crlf = 0;
size_t pos, len; size_t len;
BOOL result = FALSE; BOOL result = FALSE;
BOOL isToken = FALSE; BOOL isToken = FALSE;
size_t remain = Stream_GetRemainingLength(s); size_t remain = Stream_GetRemainingLength(s);
WINPR_ASSERT(nego); WINPR_ASSERT(nego);
str = Stream_Pointer(s); const char* str = Stream_ConstPointer(s);
pos = Stream_GetPosition(s); const size_t pos = Stream_GetPosition(s);
/* minimum length for token is 15 */ /* minimum length for token is 15 */
if (remain < 15) if (remain < 15)
return TRUE; return TRUE;
if (memcmp(Stream_Pointer(s), "Cookie: mstshash=", 17) != 0) if (memcmp(Stream_ConstPointer(s), "Cookie: mstshash=", 17) != 0)
{ {
if (memcmp(Stream_Pointer(s), "Cookie: msts=", 13) != 0) if (memcmp(Stream_ConstPointer(s), "Cookie: msts=", 13) != 0)
{ {
/* remaining bytes are neither a token nor a cookie */ /* remaining bytes are neither a token nor a cookie */
return TRUE; return TRUE;
@ -932,12 +931,12 @@ static BOOL nego_read_request_token_or_cookie(rdpNego* nego, wStream* s)
len = Stream_GetPosition(s) - pos; len = Stream_GetPosition(s) - pos;
Stream_Write_UINT16(s, 0); Stream_Write_UINT16(s, 0);
if (strnlen((char*)str, len) == len) if (strnlen(str, len) == len)
{ {
if (isToken) if (isToken)
result = nego_set_routing_token(nego, str, len); result = nego_set_routing_token(nego, str, len);
else else
result = nego_set_cookie(nego, (char*)str); result = nego_set_cookie(nego, str);
} }
} }

8
libfreerdp/core/orders.c
View File

@ -1752,7 +1752,7 @@ static BOOL update_read_glyph_index_order(wStream* s, const ORDER_INFO* orderInf
if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph_index->cbData)) if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph_index->cbData))
return FALSE; return FALSE;
CopyMemory(glyph_index->data, Stream_Pointer(s), glyph_index->cbData); CopyMemory(glyph_index->data, Stream_ConstPointer(s), glyph_index->cbData);
Stream_Seek(s, glyph_index->cbData); Stream_Seek(s, glyph_index->cbData);
} }
@ -1849,7 +1849,7 @@ static BOOL update_read_fast_index_order(wStream* s, const ORDER_INFO* orderInfo
if (!Stream_CheckAndLogRequiredLength(TAG, s, fast_index->cbData)) if (!Stream_CheckAndLogRequiredLength(TAG, s, fast_index->cbData))
return FALSE; return FALSE;
CopyMemory(fast_index->data, Stream_Pointer(s), fast_index->cbData); CopyMemory(fast_index->data, Stream_ConstPointer(s), fast_index->cbData);
Stream_Seek(s, fast_index->cbData); Stream_Seek(s, fast_index->cbData);
} }
@ -1889,7 +1889,7 @@ static BOOL update_read_fast_glyph_order(wStream* s, const ORDER_INFO* orderInfo
Stream_Read_UINT8(s, fastGlyph->cbData); Stream_Read_UINT8(s, fastGlyph->cbData);
src = Stream_Pointer(s); src = Stream_ConstPointer(s);
if (!Stream_SafeSeek(s, fastGlyph->cbData) || (fastGlyph->cbData == 0)) if (!Stream_SafeSeek(s, fastGlyph->cbData) || (fastGlyph->cbData == 0))
return FALSE; return FALSE;
@ -2727,7 +2727,7 @@ static BOOL update_decompress_brush(wStream* s, BYTE* output, size_t outSize, BY
size_t x, k; size_t x, k;
INT8 y; INT8 y;
BYTE byte = 0; BYTE byte = 0;
const BYTE* palette = Stream_Pointer(s) + 16; const BYTE* palette = Stream_PointerAs(s, const BYTE) + 16;
const size_t bytesPerPixel = ((bpp + 1) / 8); const size_t bytesPerPixel = ((bpp + 1) / 8);
if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, 4ULL + bytesPerPixel, 4ULL)) if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, 4ULL + bytesPerPixel, 4ULL))

21
libfreerdp/core/rdp.c
View File

@ -648,7 +648,6 @@ BOOL rdp_write_header(rdpRdp* rdp, wStream* s, UINT16 length, UINT16 channelId)
static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length, UINT32 sec_flags, static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length, UINT32 sec_flags,
UINT32* pad) UINT32* pad)
{ {
BYTE* data;
BOOL status; BOOL status;
WINPR_ASSERT(rdp); WINPR_ASSERT(rdp);
sec_flags |= rdp->sec_flags; sec_flags |= rdp->sec_flags;
@ -667,7 +666,7 @@ static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length, UINT32
if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS) if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
{ {
data = Stream_Pointer(s) + 12; BYTE* data = Stream_PointerAs(s, BYTE) + 12;
length = length - (data - Stream_Buffer(s)); length = length - (data - Stream_Buffer(s));
Stream_Write_UINT16(s, 0x10); /* length */ Stream_Write_UINT16(s, 0x10); /* length */
Stream_Write_UINT8(s, 0x1); /* TSFIPS_VERSION 1*/ Stream_Write_UINT8(s, 0x1); /* TSFIPS_VERSION 1*/
@ -693,7 +692,7 @@ static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length, UINT32
} }
else else
{ {
data = Stream_Pointer(s) + 8; const BYTE* data = Stream_PointerAs(s, const BYTE) + 8;
length = length - (data - Stream_Buffer(s)); length = length - (data - Stream_Buffer(s));
if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8)) if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8))
@ -702,7 +701,8 @@ static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length, UINT32
status = security_salted_mac_signature(rdp, data, length, TRUE, status = security_salted_mac_signature(rdp, data, length, TRUE,
Stream_Pointer(s), 8); Stream_Pointer(s), 8);
else else
status = security_mac_signature(rdp, data, length, Stream_Pointer(s), 8); status =
security_mac_signature(rdp, data, length, Stream_PointerAs(s, BYTE), 8);
if (!status) if (!status)
goto unlock; goto unlock;
@ -1054,7 +1054,7 @@ state_run_t rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
return STATE_RUN_FAILED; return STATE_RUN_FAILED;
} }
if (bulk_decompress(rdp->bulk, Stream_Pointer(s), SrcSize, &pDstData, &DstSize, if (bulk_decompress(rdp->bulk, Stream_ConstPointer(s), SrcSize, &pDstData, &DstSize,
compressedType)) compressedType))
{ {
cs = transport_take_from_pool(rdp->transport, DstSize); cs = transport_take_from_pool(rdp->transport, DstSize);
@ -1398,7 +1398,7 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
Stream_Read_UINT16(s, len); /* 0x10 */ Stream_Read_UINT16(s, len); /* 0x10 */
Stream_Read_UINT8(s, version); /* 0x1 */ Stream_Read_UINT8(s, version); /* 0x1 */
Stream_Read_UINT8(s, pad); Stream_Read_UINT8(s, pad);
sig = Stream_Pointer(s); sig = Stream_ConstPointer(s);
Stream_Seek(s, 8); /* signature */ Stream_Seek(s, 8); /* signature */
length -= 12; length -= 12;
padLength = length - pad; padLength = length - pad;
@ -1412,7 +1412,7 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
if (!security_fips_decrypt(Stream_Pointer(s), length, rdp)) if (!security_fips_decrypt(Stream_Pointer(s), length, rdp))
goto unlock; goto unlock;
if (!security_fips_check_signature(Stream_Pointer(s), length - pad, sig, 8, rdp)) if (!security_fips_check_signature(Stream_ConstPointer(s), length - pad, sig, 8, rdp))
goto unlock; goto unlock;
Stream_SetLength(s, Stream_Length(s) - pad); Stream_SetLength(s, Stream_Length(s) - pad);
@ -1432,14 +1432,15 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
goto unlock; goto unlock;
} }
if (!security_decrypt(Stream_Pointer(s), length, rdp)) if (!security_decrypt(Stream_PointerAs(s, BYTE), length, rdp))
goto unlock; goto unlock;
if (securityFlags & SEC_SECURE_CHECKSUM) if (securityFlags & SEC_SECURE_CHECKSUM)
status = security_salted_mac_signature(rdp, Stream_Pointer(s), length, FALSE, cmac, status = security_salted_mac_signature(rdp, Stream_ConstPointer(s), length, FALSE, cmac,
sizeof(cmac)); sizeof(cmac));
else else
status = security_mac_signature(rdp, Stream_Pointer(s), length, cmac, sizeof(cmac)); status =
security_mac_signature(rdp, Stream_ConstPointer(s), length, cmac, sizeof(cmac));
if (!status) if (!status)
goto unlock; goto unlock;

2
libfreerdp/core/rdstls.c
View File

@ -362,7 +362,7 @@ static BOOL rdstls_read_data(wLog* log, wStream* s, UINT16* pLength, const BYTE*
return TRUE; return TRUE;
} }
*pData = Stream_Pointer(s); *pData = Stream_ConstPointer(s);
*pLength = length; *pLength = length;
return Stream_SafeSeek(s, length); return Stream_SafeSeek(s, length);
} }

4
libfreerdp/core/redirection.c
View File

@ -155,7 +155,7 @@ static BOOL rdp_redirection_get_data(wStream* s, UINT32* pLength, const BYTE** p
if (!Stream_CheckAndLogRequiredLength(TAG, s, *pLength)) if (!Stream_CheckAndLogRequiredLength(TAG, s, *pLength))
return FALSE; return FALSE;
*pData = Stream_Pointer(s); *pData = Stream_ConstPointer(s);
Stream_Seek(s, *pLength); Stream_Seek(s, *pLength);
return TRUE; return TRUE;
} }
@ -314,7 +314,7 @@ static BOOL rdp_target_cert_get_element(wStream* s, UINT32* pType, UINT32* pEnco
if (!Stream_CheckAndLogRequiredLength(TAG, s, elementSize)) if (!Stream_CheckAndLogRequiredLength(TAG, s, elementSize))
return FALSE; return FALSE;
*ptr = Stream_Pointer(s); *ptr = Stream_ConstPointer(s);
*pLength = elementSize; *pLength = elementSize;
Stream_Seek(s, elementSize); Stream_Seek(s, elementSize);

6
libfreerdp/core/server.c
View File

@ -225,7 +225,7 @@ static BOOL wts_read_drdynvc_data_first(rdpPeerChannel* channel, wStream* s, int
if (!Stream_EnsureRemainingCapacity(channel->receiveData, channel->dvc_total_length)) if (!Stream_EnsureRemainingCapacity(channel->receiveData, channel->dvc_total_length))
return FALSE; return FALSE;
Stream_Write(channel->receiveData, Stream_Pointer(s), length); Stream_Write(channel->receiveData, Stream_ConstPointer(s), length);
return TRUE; return TRUE;
} }
@ -244,7 +244,7 @@ static BOOL wts_read_drdynvc_data(rdpPeerChannel* channel, wStream* s, UINT32 le
return FALSE; return FALSE;
} }
Stream_Write(channel->receiveData, Stream_Pointer(s), length); Stream_Write(channel->receiveData, Stream_ConstPointer(s), length);
if (Stream_GetPosition(channel->receiveData) >= channel->dvc_total_length) if (Stream_GetPosition(channel->receiveData) >= channel->dvc_total_length)
{ {
@ -257,7 +257,7 @@ static BOOL wts_read_drdynvc_data(rdpPeerChannel* channel, wStream* s, UINT32 le
} }
else else
{ {
ret = wts_queue_receive_data(channel, Stream_Pointer(s), length); ret = wts_queue_receive_data(channel, Stream_ConstPointer(s), length);
} }
return ret; return ret;

2
libfreerdp/core/streamdump.c
View File

@ -100,7 +100,7 @@ static
r = fread(Stream_Pointer(s), 1, size, fp); r = fread(Stream_Pointer(s), 1, size, fp);
if (r != size) if (r != size)
goto fail; goto fail;
if (crc32 != crc32b(Stream_Pointer(s), size)) if (crc32 != crc32b(Stream_ConstPointer(s), size))
goto fail; goto fail;
Stream_Seek(s, size); Stream_Seek(s, size);

2
libfreerdp/core/surface.c
View File

@ -203,7 +203,7 @@ int update_recv_surfcmds(rdpUpdate* update, wStream* s)
while (Stream_GetRemainingLength(s) >= 2) while (Stream_GetRemainingLength(s) >= 2)
{ {
const size_t start = Stream_GetPosition(s); const size_t start = Stream_GetPosition(s);
const BYTE* mark = Stream_Pointer(s); const BYTE* mark = Stream_ConstPointer(s);
Stream_Read_UINT16(s, cmdType); Stream_Read_UINT16(s, cmdType);

2
libfreerdp/core/transport.c
View File

@ -1085,7 +1085,7 @@ static int transport_default_write(rdpTransport* transport, wStream* s)
while (length > 0) while (length > 0)
{ {
ERR_clear_error(); ERR_clear_error();
status = BIO_write(transport->frontBio, Stream_Pointer(s), length); status = BIO_write(transport->frontBio, Stream_ConstPointer(s), length);
if (status <= 0) if (status <= 0)
{ {

2
libfreerdp/core/update.c
View File

@ -137,7 +137,7 @@ static BOOL update_read_bitmap_data(rdpUpdate* update, wStream* s, BITMAP_DATA*
if (!bitmapData->bitmapDataStream) if (!bitmapData->bitmapDataStream)
return FALSE; return FALSE;
memcpy(bitmapData->bitmapDataStream, Stream_Pointer(s), bitmapData->bitmapLength); memcpy(bitmapData->bitmapDataStream, Stream_ConstPointer(s), bitmapData->bitmapLength);
Stream_Seek(s, bitmapData->bitmapLength); Stream_Seek(s, bitmapData->bitmapLength);
} }

2
libfreerdp/crypto/ber.c
View File

@ -458,7 +458,7 @@ BOOL ber_read_unicode_octet_string(wStream* s, LPWSTR* str)
if (!ret) if (!ret)
return FALSE; return FALSE;
memcpy(ret, Stream_Pointer(s), length); memcpy(ret, Stream_ConstPointer(s), length);
ret[length / 2] = 0; ret[length / 2] = 0;
Stream_Seek(s, length); Stream_Seek(s, length);
*str = ret; *str = ret;

7
libfreerdp/crypto/certificate.c
View File

@ -724,7 +724,6 @@ static BOOL certificate_read_server_proprietary_certificate(rdpCertificate* cert
UINT16 wPublicKeyBlobLen = 0; UINT16 wPublicKeyBlobLen = 0;
UINT16 wSignatureBlobType = 0; UINT16 wSignatureBlobType = 0;
UINT16 wSignatureBlobLen = 0; UINT16 wSignatureBlobLen = 0;
BYTE* sigdata = NULL;
size_t sigdatalen = 0; size_t sigdatalen = 0;
WINPR_ASSERT(certificate); WINPR_ASSERT(certificate);
@ -732,7 +731,7 @@ static BOOL certificate_read_server_proprietary_certificate(rdpCertificate* cert
return FALSE; return FALSE;
/* -4, because we need to include dwVersion */ /* -4, because we need to include dwVersion */
sigdata = Stream_Pointer(s) - 4; const BYTE* sigdata = Stream_PointerAs(s, const BYTE) - 4;
Stream_Read_UINT32(s, dwSigAlgId); Stream_Read_UINT32(s, dwSigAlgId);
Stream_Read_UINT32(s, dwKeyAlgId); Stream_Read_UINT32(s, dwKeyAlgId);
@ -764,7 +763,7 @@ static BOOL certificate_read_server_proprietary_certificate(rdpCertificate* cert
if (!Stream_CheckAndLogRequiredLength(TAG, s, 4)) if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
return FALSE; return FALSE;
sigdatalen = Stream_Pointer(s) - sigdata; sigdatalen = Stream_PointerAs(s, const BYTE) - sigdata;
Stream_Read_UINT16(s, wSignatureBlobType); Stream_Read_UINT16(s, wSignatureBlobType);
if (wSignatureBlobType != BB_RSA_SIGNATURE_BLOB) if (wSignatureBlobType != BB_RSA_SIGNATURE_BLOB)
@ -847,7 +846,7 @@ static BOOL cert_write_rsa_signature(wStream* s, const void* sigData, size_t sig
static BOOL cert_write_server_certificate_v1(wStream* s, const rdpCertificate* certificate) static BOOL cert_write_server_certificate_v1(wStream* s, const rdpCertificate* certificate)
{ {
const size_t start = Stream_GetPosition(s); const size_t start = Stream_GetPosition(s);
const BYTE* sigData = Stream_Pointer(s) - sizeof(UINT32); const BYTE* sigData = Stream_PointerAs(s, const BYTE) - sizeof(UINT32);
WINPR_ASSERT(start >= 4); WINPR_ASSERT(start >= 4);
if (!Stream_EnsureRemainingCapacity(s, 10)) if (!Stream_EnsureRemainingCapacity(s, 10))

5
libfreerdp/crypto/per.c
View File

@ -494,8 +494,7 @@ static void per_write_string(wStream* s, BYTE* str, int length)
BOOL per_read_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT16 min) BOOL per_read_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT16 min)
{ {
UINT16 mlength; UINT16 mlength = 0;
BYTE* a_oct_str;
if (!per_read_length(s, &mlength)) if (!per_read_length(s, &mlength))
return FALSE; return FALSE;
@ -509,7 +508,7 @@ BOOL per_read_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT1
if (!Stream_CheckAndLogRequiredLength(TAG, s, length)) if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
return FALSE; return FALSE;
a_oct_str = Stream_Pointer(s); const BYTE* a_oct_str = Stream_ConstPointer(s);
Stream_Seek(s, length); Stream_Seek(s, length);
return per_check_oid_and_log_mismatch(a_oct_str, oct_str, length); return per_check_oid_and_log_mismatch(a_oct_str, oct_str, length);

4
libfreerdp/crypto/x509_utils.c
View File

@ -770,11 +770,11 @@ WINPR_MD_TYPE x509_utils_get_signature_alg(const X509* xcert)
char* x509_utils_get_common_name(const X509* xcert, size_t* plength) char* x509_utils_get_common_name(const X509* xcert, size_t* plength)
{ {
const X509_NAME* subject_name = X509_get_subject_name(xcert); X509_NAME* subject_name = X509_get_subject_name(xcert);
if (subject_name == NULL) if (subject_name == NULL)
return NULL; return NULL;
const int index = X509_NAME_get_index_by_NID((X509_NAME*)subject_name, NID_commonName, -1); const int index = X509_NAME_get_index_by_NID(subject_name, NID_commonName, -1);
if (index < 0) if (index < 0)
return NULL; return NULL;

4
libfreerdp/utils/rdpdr_utils.c
View File

@ -323,8 +323,8 @@ static void rdpdr_dump_packet(wLog* log, DWORD lvl, wStream* s, const char* cust
if (unicodeFlag == 0) if (unicodeFlag == 0)
Stream_Read(s, name, MIN(sizeof(name), computerNameLen)); Stream_Read(s, name, MIN(sizeof(name), computerNameLen));
else else
ConvertWCharNToUtf8((const WCHAR*)Stream_Pointer(s), ConvertWCharNToUtf8(Stream_ConstPointer(s), computerNameLen / sizeof(WCHAR),
computerNameLen / sizeof(WCHAR), name, sizeof(name)); name, sizeof(name));
} }
WLog_Print(log, lvl, WLog_Print(log, lvl,
"%s [%s | %s] [ucs:%" PRIu32 "|cp:%" PRIu32 "][len:0x%08" PRIx32 "%s [%s | %s] [ucs:%" PRIu32 "|cp:%" PRIu32 "][len:0x%08" PRIx32

2
libfreerdp/utils/smartcard_operations.c
View File

@ -809,7 +809,7 @@ LONG smartcard_irp_device_control_decode(wStream* s, UINT32 CompletionId, UINT32
scard_get_ioctl_string(ioControlCode, TRUE), scard_get_ioctl_string(ioControlCode, TRUE),
scard_get_ioctl_string(ioControlCode, FALSE), ioControlCode, scard_get_ioctl_string(ioControlCode, FALSE), ioControlCode,
Stream_GetPosition(s), Stream_Length(s), difference); Stream_GetPosition(s), Stream_Length(s), difference);
winpr_HexDump(TAG, WLOG_WARN, Stream_Pointer(s), difference); winpr_HexDump(TAG, WLOG_WARN, Stream_ConstPointer(s), difference);
} }
if (Stream_GetPosition(s) > Stream_Length(s)) if (Stream_GetPosition(s) > Stream_Length(s))

11
server/proxy/channels/pf_channel_drdynvc.c
View File

@ -335,12 +335,11 @@ static PfChannelResult DynvcTrackerPeekFn(ChannelStateTracker* tracker, BOOL fir
if (isBackData) if (isBackData)
{ {
proxyChannelDataEventInfo dev; proxyChannelDataEventInfo dev = { 0 };
size_t len; const char* name = Stream_ConstPointer(s);
const char* name = (const char*)Stream_Pointer(s); const size_t nameLen = Stream_GetRemainingLength(s);
size_t nameLen = Stream_GetRemainingLength(s);
len = strnlen(name, nameLen); const size_t len = strnlen(name, nameLen);
if ((len == 0) || (len == nameLen)) if ((len == 0) || (len == nameLen))
return PF_CHANNEL_RESULT_ERROR; return PF_CHANNEL_RESULT_ERROR;
@ -488,7 +487,7 @@ static PfChannelResult DynvcTrackerPeekFn(ChannelStateTracker* tracker, BOOL fir
return PF_CHANNEL_RESULT_ERROR; return PF_CHANNEL_RESULT_ERROR;
} }
Stream_Write(trackerState->currentPacket, Stream_Pointer(s), extraSize); Stream_Write(trackerState->currentPacket, Stream_ConstPointer(s), extraSize);
} }
WLog_DBG(TAG, WLog_DBG(TAG,
"DynvcTracker(%s [%s]): %s frags=%" PRIu32 " received=%" PRIu32 "(%" PRIu32 ")", "DynvcTracker(%s [%s]): %s frags=%" PRIu32 " received=%" PRIu32 "(%" PRIu32 ")",

4
server/proxy/channels/pf_channel_rdpdr.c
View File

@ -1553,7 +1553,7 @@ static BOOL filter_smartcard_device_list_remove(pf_channel_server_context* rdpdr
return TRUE; return TRUE;
/* Remove this device from the list */ /* Remove this device from the list */
memmove(dst, Stream_Pointer(s), (count - x - 1) * sizeof(UINT32)); memmove(dst, Stream_ConstPointer(s), (count - x - 1) * sizeof(UINT32));
count--; count--;
Stream_SetPosition(s, pos); Stream_SetPosition(s, pos);
@ -1610,7 +1610,7 @@ static BOOL filter_smartcard_device_list_announce(pf_channel_server_context* rdp
WLog_INFO(TAG, "Filtering smartcard device 0x%08" PRIx32 "", DeviceId); WLog_INFO(TAG, "Filtering smartcard device 0x%08" PRIx32 "", DeviceId);
memmove(dst, Stream_Pointer(s), Stream_GetRemainingLength(s)); memmove(dst, Stream_ConstPointer(s), Stream_GetRemainingLength(s));
Stream_SetPosition(s, pos); Stream_SetPosition(s, pos);
Stream_Write_UINT32(s, count - 1); Stream_Write_UINT32(s, count - 1);
return FALSE; return FALSE;

2
winpr/libwinpr/clipboard/synthetic_file.c
View File

@ -821,7 +821,7 @@ static void* convert_filedescriptors_to_file_list(wClipboard* clipboard, UINT32
if ((count < 1) || (count != nrDescriptors)) if ((count < 1) || (count != nrDescriptors))
return NULL; return NULL;
descriptors = (const FILEDESCRIPTORW*)Stream_Pointer(s); descriptors = Stream_ConstPointer(s);
if (formatId != ClipboardGetFormatId(clipboard, mime_FileGroupDescriptorW)) if (formatId != ClipboardGetFormatId(clipboard, mime_FileGroupDescriptorW))
return NULL; return NULL;

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

@ -112,7 +112,7 @@ BOOL sspi_gss_unwrap_token(const SecBuffer* buf, WinPrAsn1_OID* oid, uint16_t* t
if (tok_id) if (tok_id)
Stream_Read_INT16_BE(s, *tok_id); Stream_Read_INT16_BE(s, *tok_id);
token->data = (char*)Stream_Pointer(s); token->data = Stream_Pointer(s);
token->length = (UINT)Stream_GetRemainingLength(s); token->length = (UINT)Stream_GetRemainingLength(s);
return TRUE; return TRUE;

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

@ -1182,7 +1182,7 @@ size_t WinPrAsn1DecReadUtcTime(WinPrAsn1Decoder* dec, WinPrAsn1_UTCTIME* target)
if (!Stream_CheckAndLogRequiredLength(TAG, &dec->source, len) || len < 12) if (!Stream_CheckAndLogRequiredLength(TAG, &dec->source, len) || len < 12)
return 0; return 0;
Stream_StaticConstInit(s, Stream_Pointer(&dec->source), len); Stream_StaticConstInit(s, Stream_ConstPointer(&dec->source), len);
v = read2digits(s); v = read2digits(s);
if (v <= 0) if (v <= 0)
@ -1251,7 +1251,7 @@ static size_t readConstructed(WinPrAsn1Decoder* dec, wStream* s, WinPrAsn1_tag*
return 0; return 0;
target->encoding = dec->encoding; target->encoding = dec->encoding;
Stream_StaticConstInit(&target->source, Stream_Pointer(s), len); Stream_StaticConstInit(&target->source, Stream_ConstPointer(s), len);
Stream_Seek(s, len); Stream_Seek(s, len);
return ret + len; return ret + len;
} }
@ -1335,7 +1335,7 @@ size_t WinPrAsn1DecPeekContextualTag(WinPrAsn1Decoder* dec, WinPrAsn1_tagId* tag
wStream staticS; wStream staticS;
WINPR_ASSERT(dec); WINPR_ASSERT(dec);
Stream_StaticConstInit(&staticS, Stream_Pointer(&dec->source), Stream_StaticConstInit(&staticS, Stream_ConstPointer(&dec->source),
Stream_GetRemainingLength(&dec->source)); Stream_GetRemainingLength(&dec->source));
return readContextualTag(dec, &staticS, tagId, ctxtDec); return readContextualTag(dec, &staticS, tagId, ctxtDec);
} }
@ -1476,7 +1476,7 @@ wStream WinPrAsn1DecGetStream(WinPrAsn1Decoder* dec)
wStream s = { 0 }; wStream s = { 0 };
WINPR_ASSERT(dec); WINPR_ASSERT(dec);
Stream_StaticConstInit(&s, Stream_Pointer(&dec->source), Stream_StaticConstInit(&s, Stream_ConstPointer(&dec->source),
Stream_GetRemainingLength(&dec->source)); Stream_GetRemainingLength(&dec->source));
return s; return s;
} }

12
winpr/libwinpr/utils/test/TestStream.c
View File

@ -10,15 +10,15 @@ static BOOL TestStream_Verify(wStream* s, size_t mincap, size_t len, size_t pos)
return FALSE; return FALSE;
} }
if (Stream_Pointer(s) == NULL) if (Stream_ConstPointer(s) == NULL)
{ {
printf("stream pointer is null\n"); printf("stream pointer is null\n");
return FALSE; return FALSE;
} }
if (Stream_Pointer(s) < Stream_Buffer(s)) if (Stream_PointerAs(s, BYTE*) < Stream_Buffer(s))
{ {
printf("stream pointer (%p) or buffer (%p) is invalid\n", (void*)Stream_Pointer(s), printf("stream pointer (%p) or buffer (%p) is invalid\n", Stream_ConstPointer(s),
(void*)Stream_Buffer(s)); (void*)Stream_Buffer(s));
return FALSE; return FALSE;
} }
@ -523,7 +523,7 @@ static BOOL TestStream_Zero(void)
if (s->pointer != s->buffer + 5) if (s->pointer != s->buffer + 5)
goto out; goto out;
if (memcmp(Stream_Pointer(s), data + 5, sizeof(data) - 5) != 0) if (memcmp(Stream_ConstPointer(s), data + 5, sizeof(data) - 5) != 0)
goto out; goto out;
Stream_SetPosition(s, 0); Stream_SetPosition(s, 0);
@ -571,7 +571,7 @@ static BOOL TestStream_Fill(void)
if (s->pointer != s->buffer + sizeof(fill)) if (s->pointer != s->buffer + sizeof(fill))
goto out; goto out;
if (memcmp(Stream_Pointer(s), data + sizeof(fill), sizeof(data) - sizeof(fill)) != 0) if (memcmp(Stream_ConstPointer(s), data + sizeof(fill), sizeof(data) - sizeof(fill)) != 0)
goto out; goto out;
Stream_SetPosition(s, 0); Stream_SetPosition(s, 0);
@ -579,7 +579,7 @@ static BOOL TestStream_Fill(void)
if (s->pointer != s->buffer) if (s->pointer != s->buffer)
goto out; goto out;
if (memcmp(Stream_Pointer(s), fill, sizeof(fill)) != 0) if (memcmp(Stream_ConstPointer(s), fill, sizeof(fill)) != 0)
goto out; goto out;
rc = TRUE; rc = TRUE;