2012-05-25 11:24:42 +04:00
|
|
|
/*
|
|
|
|
* WinPR: Windows Portable Runtime
|
|
|
|
* Stream Utils
|
|
|
|
*
|
|
|
|
* Copyright 2011 Vic Lee
|
|
|
|
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2022-02-16 12:08:00 +03:00
|
|
|
#include <winpr/config.h>
|
2012-08-15 01:20:53 +04:00
|
|
|
|
2021-06-09 15:03:34 +03:00
|
|
|
#include <winpr/assert.h>
|
2012-05-25 11:24:42 +04:00
|
|
|
#include <winpr/crt.h>
|
|
|
|
#include <winpr/stream.h>
|
|
|
|
|
2021-10-04 15:36:28 +03:00
|
|
|
#include "stream.h"
|
2021-10-05 09:53:20 +03:00
|
|
|
#include "../log.h"
|
|
|
|
|
|
|
|
#define STREAM_TAG WINPR_TAG("wStream")
|
|
|
|
|
|
|
|
#define STREAM_ASSERT(cond) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (!(cond)) \
|
|
|
|
{ \
|
|
|
|
WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __FUNCTION__, \
|
2023-01-24 16:37:41 +03:00
|
|
|
(size_t)__LINE__); \
|
2021-10-05 09:53:20 +03:00
|
|
|
winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \
|
|
|
|
abort(); \
|
|
|
|
} \
|
2021-10-04 15:36:28 +03:00
|
|
|
} while (0)
|
|
|
|
|
2015-03-26 19:09:47 +03:00
|
|
|
BOOL Stream_EnsureCapacity(wStream* s, size_t size)
|
2012-12-12 09:49:15 +04:00
|
|
|
{
|
2021-06-16 12:54:11 +03:00
|
|
|
WINPR_ASSERT(s);
|
2012-12-12 09:49:15 +04:00
|
|
|
if (s->capacity < size)
|
|
|
|
{
|
2013-04-30 07:55:44 +04:00
|
|
|
size_t position;
|
2013-05-02 02:15:55 +04:00
|
|
|
size_t old_capacity;
|
2013-05-16 00:22:58 +04:00
|
|
|
size_t new_capacity;
|
2015-03-11 09:59:56 +03:00
|
|
|
BYTE* new_buf;
|
2013-05-02 02:15:55 +04:00
|
|
|
|
|
|
|
old_capacity = s->capacity;
|
2013-05-16 00:22:58 +04:00
|
|
|
new_capacity = old_capacity;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
new_capacity *= 2;
|
2019-11-06 17:24:51 +03:00
|
|
|
} while (new_capacity < size);
|
2013-04-30 07:55:44 +04:00
|
|
|
|
|
|
|
position = Stream_GetPosition(s);
|
|
|
|
|
2018-10-16 12:33:03 +03:00
|
|
|
if (!s->isOwner)
|
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
new_buf = (BYTE*)malloc(new_capacity);
|
2018-10-16 12:33:03 +03:00
|
|
|
CopyMemory(new_buf, s->buffer, s->capacity);
|
|
|
|
s->isOwner = TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
new_buf = (BYTE*)realloc(s->buffer, new_capacity);
|
2018-10-16 12:33:03 +03:00
|
|
|
}
|
|
|
|
|
2015-03-11 09:59:56 +03:00
|
|
|
if (!new_buf)
|
2015-03-26 19:09:47 +03:00
|
|
|
return FALSE;
|
2015-03-11 09:59:56 +03:00
|
|
|
s->buffer = new_buf;
|
|
|
|
s->capacity = new_capacity;
|
|
|
|
s->length = new_capacity;
|
2013-05-02 02:15:55 +04:00
|
|
|
ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity);
|
2013-04-30 07:55:44 +04:00
|
|
|
|
|
|
|
Stream_SetPosition(s, position);
|
2012-12-12 09:49:15 +04:00
|
|
|
}
|
2015-03-26 19:09:47 +03:00
|
|
|
return TRUE;
|
2012-12-12 09:49:15 +04:00
|
|
|
}
|
|
|
|
|
2015-03-26 19:09:47 +03:00
|
|
|
BOOL Stream_EnsureRemainingCapacity(wStream* s, size_t size)
|
2013-05-02 02:15:55 +04:00
|
|
|
{
|
|
|
|
if (Stream_GetPosition(s) + size > Stream_Capacity(s))
|
2015-03-26 19:09:47 +03:00
|
|
|
return Stream_EnsureCapacity(s, Stream_Capacity(s) + size);
|
|
|
|
return TRUE;
|
2013-05-02 02:15:55 +04:00
|
|
|
}
|
|
|
|
|
2012-12-10 23:43:48 +04:00
|
|
|
wStream* Stream_New(BYTE* buffer, size_t size)
|
2012-05-25 11:24:42 +04:00
|
|
|
{
|
2012-12-10 23:43:48 +04:00
|
|
|
wStream* s;
|
2012-05-25 11:24:42 +04:00
|
|
|
|
2015-10-23 19:06:17 +03:00
|
|
|
if (!buffer && !size)
|
|
|
|
return NULL;
|
|
|
|
|
2012-12-10 23:43:48 +04:00
|
|
|
s = malloc(sizeof(wStream));
|
2015-02-10 12:26:32 +03:00
|
|
|
if (!s)
|
|
|
|
return NULL;
|
2012-05-25 11:24:42 +04:00
|
|
|
|
2015-02-10 12:26:32 +03:00
|
|
|
if (buffer)
|
|
|
|
s->buffer = buffer;
|
|
|
|
else
|
2019-11-06 17:24:51 +03:00
|
|
|
s->buffer = (BYTE*)malloc(size);
|
2015-02-10 12:26:32 +03:00
|
|
|
|
|
|
|
if (!s->buffer)
|
|
|
|
{
|
|
|
|
free(s);
|
|
|
|
return NULL;
|
2012-05-25 11:24:42 +04:00
|
|
|
}
|
|
|
|
|
2015-02-10 12:26:32 +03:00
|
|
|
s->pointer = s->buffer;
|
|
|
|
s->capacity = size;
|
|
|
|
s->length = size;
|
|
|
|
|
|
|
|
s->pool = NULL;
|
|
|
|
s->count = 0;
|
2018-10-16 12:33:03 +03:00
|
|
|
s->isAllocatedStream = TRUE;
|
|
|
|
s->isOwner = TRUE;
|
2012-05-25 22:03:56 +04:00
|
|
|
return s;
|
2012-05-25 11:24:42 +04:00
|
|
|
}
|
|
|
|
|
2021-10-14 09:42:49 +03:00
|
|
|
wStream* Stream_StaticConstInit(wStream* s, const BYTE* buffer, size_t size)
|
2018-10-16 12:33:03 +03:00
|
|
|
{
|
2021-10-14 09:42:49 +03:00
|
|
|
union
|
|
|
|
{
|
|
|
|
BYTE* b;
|
|
|
|
const BYTE* cb;
|
|
|
|
} cnv;
|
|
|
|
|
|
|
|
cnv.cb = buffer;
|
|
|
|
return Stream_StaticInit(s, cnv.b, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
wStream* Stream_StaticInit(wStream* s, BYTE* buffer, size_t size)
|
|
|
|
{
|
|
|
|
const wStream empty = { 0 };
|
|
|
|
|
2021-06-09 15:03:34 +03:00
|
|
|
WINPR_ASSERT(s);
|
|
|
|
WINPR_ASSERT(buffer);
|
2018-10-16 12:33:03 +03:00
|
|
|
|
2021-10-14 09:42:49 +03:00
|
|
|
*s = empty;
|
2018-10-16 12:33:03 +03:00
|
|
|
s->buffer = s->pointer = buffer;
|
|
|
|
s->capacity = s->length = size;
|
|
|
|
s->pool = NULL;
|
|
|
|
s->count = 0;
|
|
|
|
s->isAllocatedStream = FALSE;
|
|
|
|
s->isOwner = FALSE;
|
2021-10-14 09:42:49 +03:00
|
|
|
return s;
|
2018-10-16 12:33:03 +03:00
|
|
|
}
|
|
|
|
|
2021-10-04 15:36:28 +03:00
|
|
|
void Stream_EnsureValidity(wStream* s)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
|
|
|
|
STREAM_ASSERT(s);
|
|
|
|
STREAM_ASSERT(s->pointer >= s->buffer);
|
|
|
|
|
|
|
|
cur = (size_t)(s->pointer - s->buffer);
|
|
|
|
STREAM_ASSERT(cur <= s->capacity);
|
|
|
|
STREAM_ASSERT(s->length <= s->capacity);
|
|
|
|
}
|
|
|
|
|
2012-12-10 23:43:48 +04:00
|
|
|
void Stream_Free(wStream* s, BOOL bFreeBuffer)
|
2012-05-25 11:24:42 +04:00
|
|
|
{
|
2013-11-08 22:57:41 +04:00
|
|
|
if (s)
|
2012-05-25 11:24:42 +04:00
|
|
|
{
|
2021-10-04 15:36:28 +03:00
|
|
|
Stream_EnsureValidity(s);
|
2018-10-16 12:33:03 +03:00
|
|
|
if (bFreeBuffer && s->isOwner)
|
2015-05-11 10:07:39 +03:00
|
|
|
free(s->buffer);
|
2012-05-25 11:24:42 +04:00
|
|
|
|
2018-10-16 12:33:03 +03:00
|
|
|
if (s->isAllocatedStream)
|
|
|
|
free(s);
|
2012-05-25 11:24:42 +04:00
|
|
|
}
|
|
|
|
}
|
2021-10-04 09:48:38 +03:00
|
|
|
|
|
|
|
BOOL Stream_SetLength(wStream* _s, size_t _l)
|
|
|
|
{
|
|
|
|
if ((_l) > Stream_Capacity(_s))
|
|
|
|
{
|
|
|
|
_s->length = 0;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
_s->length = _l;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_SetPosition(wStream* _s, size_t _p)
|
|
|
|
{
|
|
|
|
if ((_p) > Stream_Capacity(_s))
|
|
|
|
{
|
|
|
|
_s->pointer = _s->buffer;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
_s->pointer = _s->buffer + (_p);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2021-10-05 09:53:20 +03:00
|
|
|
void Stream_SealLength(wStream* _s)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
WINPR_ASSERT(_s->buffer <= _s->pointer);
|
|
|
|
cur = (size_t)(_s->pointer - _s->buffer);
|
|
|
|
WINPR_ASSERT(cur <= _s->capacity);
|
|
|
|
if (cur <= _s->capacity)
|
|
|
|
_s->length = cur;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was written out of bounds");
|
|
|
|
winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
|
|
|
|
_s->length = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-04 09:48:38 +03:00
|
|
|
#if defined(WITH_WINPR_DEPRECATED)
|
|
|
|
BOOL Stream_SetPointer(wStream* _s, BYTE* _p)
|
|
|
|
{
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
if (!_p || (_s->buffer > _p) || (_s->buffer + _s->capacity < _p))
|
|
|
|
{
|
|
|
|
_s->pointer = _s->buffer;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
_s->pointer = _p;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_SetBuffer(wStream* _s, BYTE* _b)
|
|
|
|
{
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
WINPR_ASSERT(_b);
|
|
|
|
|
|
|
|
_s->buffer = _b;
|
|
|
|
_s->pointer = _b;
|
|
|
|
return _s->buffer != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stream_SetCapacity(wStream* _s, size_t _c)
|
|
|
|
{
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
_s->capacity = _c;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2021-10-05 09:53:20 +03:00
|
|
|
|
2022-01-31 12:29:41 +03:00
|
|
|
size_t Stream_GetRemainingCapacity(const wStream* _s)
|
2021-10-05 09:53:20 +03:00
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
WINPR_ASSERT(_s->buffer <= _s->pointer);
|
|
|
|
cur = (size_t)(_s->pointer - _s->buffer);
|
|
|
|
WINPR_ASSERT(cur <= _s->capacity);
|
|
|
|
if (cur > _s->capacity)
|
|
|
|
{
|
|
|
|
WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was written out of bounds");
|
|
|
|
winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return (_s->capacity - cur);
|
|
|
|
}
|
|
|
|
|
2022-01-31 12:29:41 +03:00
|
|
|
size_t Stream_GetRemainingLength(const wStream* _s)
|
2021-10-05 09:53:20 +03:00
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
WINPR_ASSERT(_s);
|
|
|
|
WINPR_ASSERT(_s->buffer <= _s->pointer);
|
|
|
|
WINPR_ASSERT(_s->length <= _s->capacity);
|
|
|
|
cur = (size_t)(_s->pointer - _s->buffer);
|
|
|
|
WINPR_ASSERT(cur <= _s->length);
|
|
|
|
if (cur > _s->length)
|
|
|
|
{
|
|
|
|
WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was read out of bounds");
|
|
|
|
winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return (_s->length - cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_Write_UTF16_String(wStream* s, const WCHAR* src, size_t length)
|
|
|
|
{
|
|
|
|
size_t x;
|
|
|
|
|
|
|
|
WINPR_ASSERT(s);
|
|
|
|
WINPR_ASSERT(src || (length == 0));
|
|
|
|
if (!s || !src)
|
|
|
|
return FALSE;
|
|
|
|
|
2023-01-24 14:19:56 +03:00
|
|
|
if (!Stream_CheckAndLogRequiredCapacityOfSize(STREAM_TAG, (s), length, sizeof(WCHAR)))
|
2021-10-05 09:53:20 +03:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
for (x = 0; x < length; x++)
|
|
|
|
Stream_Write_UINT16(s, src[x]);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_Read_UTF16_String(wStream* s, WCHAR* dst, size_t length)
|
|
|
|
{
|
|
|
|
size_t x;
|
|
|
|
|
|
|
|
WINPR_ASSERT(s);
|
|
|
|
WINPR_ASSERT(dst);
|
|
|
|
|
|
|
|
if (Stream_GetRemainingLength(s) / sizeof(WCHAR) < length)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
for (x = 0; x < length; x++)
|
|
|
|
Stream_Read_UINT16(s, dst[x]);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
2022-04-19 15:29:17 +03:00
|
|
|
|
2023-01-24 13:24:47 +03:00
|
|
|
BOOL Stream_CheckAndLogRequiredCapacityEx(const char* tag, DWORD level, wStream* s, size_t nmemb,
|
|
|
|
size_t size, const char* fmt, ...)
|
|
|
|
{
|
|
|
|
WINPR_ASSERT(size != 0);
|
|
|
|
const size_t actual = Stream_GetRemainingCapacity(s) / size;
|
|
|
|
|
|
|
|
if (actual < nmemb)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
Stream_CheckAndLogRequiredCapacityExVa(tag, level, s, nmemb, size, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredCapacityExVa(const char* tag, DWORD level, wStream* s, size_t nmemb,
|
|
|
|
size_t size, const char* fmt, va_list args)
|
|
|
|
{
|
|
|
|
WINPR_ASSERT(size != 0);
|
|
|
|
const size_t actual = Stream_GetRemainingCapacity(s) / size;
|
|
|
|
|
|
|
|
if (actual < nmemb)
|
|
|
|
return Stream_CheckAndLogRequiredCapacityWLogExVa(WLog_Get(tag), level, s, nmemb, size, fmt,
|
|
|
|
args);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredCapacityWLogExVa(wLog* log, DWORD level, wStream* s, size_t nmemb,
|
|
|
|
size_t size, const char* fmt, va_list args)
|
|
|
|
{
|
|
|
|
|
|
|
|
WINPR_ASSERT(size != 0);
|
|
|
|
const size_t actual = Stream_GetRemainingCapacity(s) / size;
|
|
|
|
|
|
|
|
if (actual < nmemb)
|
|
|
|
{
|
|
|
|
char prefix[1024] = { 0 };
|
|
|
|
|
|
|
|
vsnprintf(prefix, sizeof(prefix), fmt, args);
|
|
|
|
|
|
|
|
WLog_Print(log, level,
|
|
|
|
"[%s] invalid remaining capacity, got %" PRIuz ", require at least %" PRIu64
|
|
|
|
" [element size=%" PRIuz "]",
|
|
|
|
prefix, actual, nmemb, size);
|
|
|
|
winpr_log_backtrace_ex(log, level, 20);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredCapacityWLogEx(wLog* log, DWORD level, wStream* s, size_t nmemb,
|
|
|
|
size_t size, const char* fmt, ...)
|
|
|
|
{
|
|
|
|
|
|
|
|
WINPR_ASSERT(size != 0);
|
|
|
|
const size_t actual = Stream_GetRemainingCapacity(s) / size;
|
|
|
|
|
|
|
|
if (actual < nmemb)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
Stream_CheckAndLogRequiredCapacityWLogExVa(log, level, s, nmemb, size, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2022-04-19 15:29:17 +03:00
|
|
|
BOOL Stream_CheckAndLogRequiredLengthEx(const char* tag, DWORD level, wStream* s, UINT64 len,
|
|
|
|
const char* fmt, ...)
|
|
|
|
{
|
|
|
|
const size_t actual = Stream_GetRemainingLength(s);
|
|
|
|
|
|
|
|
if (actual < len)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
Stream_CheckAndLogRequiredLengthExVa(tag, level, s, len, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredLengthExVa(const char* tag, DWORD level, wStream* s, UINT64 len,
|
|
|
|
const char* fmt, va_list args)
|
|
|
|
{
|
|
|
|
const size_t actual = Stream_GetRemainingLength(s);
|
|
|
|
|
|
|
|
if (actual < len)
|
|
|
|
return Stream_CheckAndLogRequiredLengthWLogExVa(WLog_Get(tag), level, s, len, fmt, args);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredLengthWLogEx(wLog* log, DWORD level, wStream* s, UINT64 len,
|
|
|
|
const char* fmt, ...)
|
|
|
|
{
|
|
|
|
const size_t actual = Stream_GetRemainingLength(s);
|
|
|
|
|
|
|
|
if (actual < len)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
Stream_CheckAndLogRequiredLengthWLogExVa(log, level, s, len, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL Stream_CheckAndLogRequiredLengthWLogExVa(wLog* log, DWORD level, wStream* s, UINT64 len,
|
|
|
|
const char* fmt, va_list args)
|
|
|
|
{
|
|
|
|
const size_t actual = Stream_GetRemainingLength(s);
|
|
|
|
|
|
|
|
if (actual < len)
|
|
|
|
{
|
|
|
|
char prefix[1024] = { 0 };
|
|
|
|
|
|
|
|
vsnprintf(prefix, sizeof(prefix), fmt, args);
|
|
|
|
|
2023-01-24 13:24:47 +03:00
|
|
|
WLog_Print(log, level, "[%s] invalid length, got %" PRIuz ", require at least %" PRIuz,
|
2022-04-19 15:29:17 +03:00
|
|
|
prefix, actual, len);
|
|
|
|
winpr_log_backtrace_ex(log, level, 20);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
2022-10-27 16:37:25 +03:00
|
|
|
|
|
|
|
SSIZE_T Stream_Write_UTF16_String_From_UTF8(wStream* s, size_t dlen, const char* src, size_t length,
|
|
|
|
BOOL fill)
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
WCHAR* wc;
|
|
|
|
BYTE* b;
|
|
|
|
} cnv;
|
|
|
|
cnv.b = Stream_Pointer(s);
|
|
|
|
|
|
|
|
if (length == 0)
|
|
|
|
return 0;
|
|
|
|
|
2023-01-24 13:24:47 +03:00
|
|
|
if (!Stream_CheckAndLogRequiredCapacityOfSize(STREAM_TAG, s, dlen, sizeof(WCHAR)))
|
2022-10-27 16:37:25 +03:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
SSIZE_T rc = ConvertUtf8NToWChar(src, length, cnv.wc, dlen);
|
|
|
|
if (rc < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
Stream_Seek(s, (size_t)rc * sizeof(WCHAR));
|
|
|
|
|
|
|
|
if (fill)
|
|
|
|
Stream_Zero(s, (dlen - (size_t)rc) * sizeof(WCHAR));
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
char* Stream_Read_UTF16_String_As_UTF8(wStream* s, size_t dlen, size_t* psize)
|
|
|
|
{
|
|
|
|
union
|
|
|
|
{
|
|
|
|
const WCHAR* wc;
|
|
|
|
const BYTE* b;
|
|
|
|
} cnv;
|
|
|
|
cnv.b = Stream_Pointer(s);
|
|
|
|
if (dlen > SIZE_MAX / sizeof(WCHAR))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!Stream_CheckAndLogRequiredLength(STREAM_TAG, s, dlen * sizeof(WCHAR)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
Stream_Seek(s, dlen * sizeof(WCHAR));
|
|
|
|
return ConvertWCharNToUtf8Alloc(cnv.wc, dlen, psize);
|
|
|
|
}
|
|
|
|
|
|
|
|
SSIZE_T Stream_Read_UTF16_String_As_UTF8_Buffer(wStream* s, size_t wcharLength, char* utfBuffer,
|
|
|
|
size_t utfBufferCharLength)
|
|
|
|
{
|
|
|
|
const WCHAR* ptr = (const WCHAR*)Stream_Pointer(s);
|
|
|
|
if (wcharLength > SIZE_MAX / sizeof(WCHAR))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!Stream_CheckAndLogRequiredLength(STREAM_TAG, s, wcharLength * sizeof(WCHAR)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
Stream_Seek(s, wcharLength * sizeof(WCHAR));
|
|
|
|
return ConvertWCharNToUtf8(ptr, wcharLength, utfBuffer, utfBufferCharLength);
|
|
|
|
}
|
2023-01-18 12:42:17 +03:00
|
|
|
|
|
|
|
BOOL Stream_SafeSeekEx(wStream* s, size_t size, const char* file, size_t line, const char* fkt)
|
|
|
|
{
|
|
|
|
if (!Stream_CheckAndLogRequiredLengthEx(STREAM_TAG, WLOG_WARN, s, size, "%s(%s:%" PRIuz ")",
|
|
|
|
fkt, file, line))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
Stream_Seek(s, size);
|
|
|
|
return TRUE;
|
|
|
|
}
|