FreeRDP/winpr/libwinpr/utils/stream.c
2021-10-06 09:49:07 +02:00

309 lines
6.6 KiB
C

/*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <winpr/assert.h>
#include <winpr/crt.h>
#include <winpr/stream.h>
#include "stream.h"
#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__, \
__LINE__); \
winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \
abort(); \
} \
} while (0)
BOOL Stream_EnsureCapacity(wStream* s, size_t size)
{
WINPR_ASSERT(s);
if (s->capacity < size)
{
size_t position;
size_t old_capacity;
size_t new_capacity;
BYTE* new_buf;
old_capacity = s->capacity;
new_capacity = old_capacity;
do
{
new_capacity *= 2;
} while (new_capacity < size);
position = Stream_GetPosition(s);
if (!s->isOwner)
{
new_buf = (BYTE*)malloc(new_capacity);
CopyMemory(new_buf, s->buffer, s->capacity);
s->isOwner = TRUE;
}
else
{
new_buf = (BYTE*)realloc(s->buffer, new_capacity);
}
if (!new_buf)
return FALSE;
s->buffer = new_buf;
s->capacity = new_capacity;
s->length = new_capacity;
ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity);
Stream_SetPosition(s, position);
}
return TRUE;
}
BOOL Stream_EnsureRemainingCapacity(wStream* s, size_t size)
{
if (Stream_GetPosition(s) + size > Stream_Capacity(s))
return Stream_EnsureCapacity(s, Stream_Capacity(s) + size);
return TRUE;
}
wStream* Stream_New(BYTE* buffer, size_t size)
{
wStream* s;
if (!buffer && !size)
return NULL;
s = malloc(sizeof(wStream));
if (!s)
return NULL;
if (buffer)
s->buffer = buffer;
else
s->buffer = (BYTE*)malloc(size);
if (!s->buffer)
{
free(s);
return NULL;
}
s->pointer = s->buffer;
s->capacity = size;
s->length = size;
s->pool = NULL;
s->count = 0;
s->isAllocatedStream = TRUE;
s->isOwner = TRUE;
return s;
}
void Stream_StaticInit(wStream* s, BYTE* buffer, size_t size)
{
WINPR_ASSERT(s);
WINPR_ASSERT(buffer);
s->buffer = s->pointer = buffer;
s->capacity = s->length = size;
s->pool = NULL;
s->count = 0;
s->isAllocatedStream = FALSE;
s->isOwner = FALSE;
}
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);
/* Length is only valid after a call to Stream_SealLength */
if (s->length > 0)
{
STREAM_ASSERT(cur <= s->length);
}
}
void Stream_Free(wStream* s, BOOL bFreeBuffer)
{
if (s)
{
Stream_EnsureValidity(s);
if (bFreeBuffer && s->isOwner)
free(s->buffer);
if (s->isAllocatedStream)
free(s);
}
}
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;
}
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;
}
}
#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
size_t Stream_GetRemainingCapacity(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)
{
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);
}
size_t Stream_GetRemainingLength(wStream* _s)
{
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;
if (Stream_GetRemainingCapacity(s) / sizeof(WCHAR) < length)
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;
}