/* * WinPR: Windows Portable Runtime * Stream Utils * * Copyright 2011 Vic Lee * Copyright 2012 Marc-Andre Moreau * * 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 #include #include #include "stream.h" #define STREAM_ASSERT(cond) \ do \ { \ if (!(cond)) \ { \ const char* tag = "com.freerdp.winpr.wStream"; \ WLog_FATAL(tag, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __FUNCTION__, __LINE__); \ winpr_log_backtrace(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; } #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