FreeRDP
Loading...
Searching...
No Matches
stream.c
1/*
2 * WinPR: Windows Portable Runtime
3 * Stream Utils
4 *
5 * Copyright 2011 Vic Lee
6 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21#include <winpr/config.h>
22
23#include <winpr/assert.h>
24#include <winpr/crt.h>
25#include <winpr/stream.h>
26
27#include "stream.h"
28#include "../log.h"
29
30#define STREAM_TAG WINPR_TAG("wStream")
31
32#define STREAM_ASSERT(cond) \
33 do \
34 { \
35 if (!(cond)) \
36 { \
37 WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __func__, \
38 (size_t)__LINE__); \
39 winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \
40 abort(); \
41 } \
42 } while (0)
43
44BOOL Stream_EnsureCapacity(wStream* s, size_t size)
45{
46 WINPR_ASSERT(s);
47 if (s->capacity >= size)
48 return TRUE;
49
50 const size_t increment = 128ull;
51 const size_t old_capacity = s->capacity;
52 const size_t new_capacity = size + increment - size % increment;
53 const size_t position = Stream_GetPosition(s);
54
55 BYTE* new_buf = nullptr;
56 if (!s->isOwner)
57 {
58 new_buf = (BYTE*)malloc(new_capacity);
59 if (!new_buf)
60 return FALSE;
61
62 CopyMemory(new_buf, s->buffer, s->capacity);
63 s->isOwner = TRUE;
64 }
65 else
66 {
67 new_buf = (BYTE*)realloc(s->buffer, new_capacity);
68 if (!new_buf)
69 return FALSE;
70 }
71
72 s->buffer = new_buf;
73 s->capacity = new_capacity;
74 s->length = new_capacity;
75 ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity);
76
77 return Stream_SetPosition(s, position);
78}
79
80BOOL Stream_EnsureRemainingCapacity(wStream* s, size_t size)
81{
82 if (Stream_GetPosition(s) + size > Stream_Capacity(s))
83 return Stream_EnsureCapacity(s, Stream_Capacity(s) + size);
84 return TRUE;
85}
86
87wStream* Stream_New(BYTE* buffer, size_t size)
88{
89 wStream* s = nullptr;
90
91 if (!buffer && !size)
92 return nullptr;
93
94 s = calloc(1, sizeof(wStream));
95 if (!s)
96 return nullptr;
97
98 if (buffer)
99 s->buffer = buffer;
100 else
101 s->buffer = (BYTE*)malloc(size);
102
103 if (!s->buffer)
104 {
105 free(s);
106 return nullptr;
107 }
108
109 s->pointer = s->buffer;
110 s->capacity = size;
111 s->length = size;
112
113 s->pool = nullptr;
114 s->count = 1;
115 s->isAllocatedStream = TRUE;
116 s->isOwner = TRUE;
117 return s;
118}
119
120wStream* Stream_StaticConstInit(wStream* s, const BYTE* buffer, size_t size)
121{
122 union
123 {
124 BYTE* b;
125 const BYTE* cb;
126 } cnv;
127
128 cnv.cb = buffer;
129 return Stream_StaticInit(s, cnv.b, size);
130}
131
132wStream* Stream_StaticInit(wStream* s, BYTE* buffer, size_t size)
133{
134 const wStream empty = WINPR_C_ARRAY_INIT;
135
136 WINPR_ASSERT(s);
137 WINPR_ASSERT(buffer);
138
139 *s = empty;
140 s->buffer = s->pointer = buffer;
141 s->capacity = s->length = size;
142 s->pool = nullptr;
143 s->count = 1;
144 s->isAllocatedStream = FALSE;
145 s->isOwner = FALSE;
146 return s;
147}
148
149void Stream_EnsureValidity(wStream* s)
150{
151 size_t cur = 0;
152
153 STREAM_ASSERT(s);
154 STREAM_ASSERT(s->pointer >= s->buffer);
155
156 cur = (size_t)(s->pointer - s->buffer);
157 STREAM_ASSERT(cur <= s->capacity);
158 STREAM_ASSERT(s->length <= s->capacity);
159}
160
161void Stream_Free(wStream* s, BOOL bFreeBuffer)
162{
163 if (s)
164 {
165 Stream_EnsureValidity(s);
166 if (bFreeBuffer && s->isOwner)
167 free(s->buffer);
168
169 if (s->isAllocatedStream)
170 free(s);
171 }
172}
173
174BOOL Stream_SetLength(wStream* _s, size_t _l)
175{
176 if ((_l) > Stream_Capacity(_s))
177 {
178 _s->length = 0;
179 return FALSE;
180 }
181 _s->length = _l;
182 return TRUE;
183}
184
185BOOL Stream_SetPosition(wStream* _s, size_t _p)
186{
187 if ((_p) > Stream_Capacity(_s))
188 {
189 _s->pointer = _s->buffer;
190 return FALSE;
191 }
192 _s->pointer = _s->buffer + (_p);
193 return TRUE;
194}
195
196void Stream_SealLength(wStream* _s)
197{
198 size_t cur = 0;
199 WINPR_ASSERT(_s);
200 WINPR_ASSERT(_s->buffer <= _s->pointer);
201 cur = (size_t)(_s->pointer - _s->buffer);
202 WINPR_ASSERT(cur <= _s->capacity);
203 if (cur <= _s->capacity)
204 _s->length = cur;
205 else
206 {
207 WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was written out of bounds");
208 winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
209 _s->length = 0;
210 }
211}
212
213#if defined(WITH_WINPR_DEPRECATED)
214BOOL Stream_SetPointer(wStream* _s, BYTE* _p)
215{
216 WINPR_ASSERT(_s);
217 if (!_p || (_s->buffer > _p) || (_s->buffer + _s->capacity < _p))
218 {
219 _s->pointer = _s->buffer;
220 return FALSE;
221 }
222 _s->pointer = _p;
223 return TRUE;
224}
225
226BOOL Stream_SetBuffer(wStream* _s, BYTE* _b)
227{
228 WINPR_ASSERT(_s);
229 WINPR_ASSERT(_b);
230
231 _s->buffer = _b;
232 _s->pointer = _b;
233 return _s->buffer != nullptr;
234}
235
236void Stream_SetCapacity(wStream* _s, size_t _c)
237{
238 WINPR_ASSERT(_s);
239 _s->capacity = _c;
240}
241
242#endif
243
244size_t Stream_GetRemainingCapacity(const wStream* _s)
245{
246 size_t cur = 0;
247 WINPR_ASSERT(_s);
248 WINPR_ASSERT(_s->buffer <= _s->pointer);
249 cur = (size_t)(_s->pointer - _s->buffer);
250 WINPR_ASSERT(cur <= _s->capacity);
251 if (cur > _s->capacity)
252 {
253 WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was written out of bounds");
254 winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
255 return 0;
256 }
257 return (_s->capacity - cur);
258}
259
260size_t Stream_GetRemainingLength(const wStream* _s)
261{
262 size_t cur = 0;
263 WINPR_ASSERT(_s);
264 WINPR_ASSERT(_s->buffer <= _s->pointer);
265 WINPR_ASSERT(_s->length <= _s->capacity);
266 cur = (size_t)(_s->pointer - _s->buffer);
267 WINPR_ASSERT(cur <= _s->length);
268 if (cur > _s->length)
269 {
270 WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was read out of bounds");
271 winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20);
272 return 0;
273 }
274 return (_s->length - cur);
275}
276
277BOOL Stream_Write_UTF16_String(wStream* s, const WCHAR* src, size_t length)
278{
279 WINPR_ASSERT(s);
280 WINPR_ASSERT(src || (length == 0));
281 if (!s || !src)
282 return FALSE;
283
284 if (!Stream_CheckAndLogRequiredCapacityOfSize(STREAM_TAG, (s), length, sizeof(WCHAR)))
285 return FALSE;
286
287 for (size_t x = 0; x < length; x++)
288 Stream_Write_UINT16(s, src[x]);
289
290 return TRUE;
291}
292
293BOOL Stream_Read_UTF16_String(wStream* s, WCHAR* dst, size_t length)
294{
295 WINPR_ASSERT(s);
296 WINPR_ASSERT(dst);
297
298 if (!Stream_CheckAndLogRequiredLengthOfSize(STREAM_TAG, s, length, sizeof(WCHAR)))
299 return FALSE;
300
301 for (size_t x = 0; x < length; x++)
302 Stream_Read_UINT16(s, dst[x]);
303
304 return TRUE;
305}
306
307BOOL Stream_CheckAndLogRequiredCapacityEx(const char* tag, DWORD level, wStream* s, size_t nmemb,
308 size_t size, const char* fmt, ...)
309{
310 WINPR_ASSERT(size != 0);
311 const size_t actual = Stream_GetRemainingCapacity(s) / size;
312
313 if (actual < nmemb)
314 {
315 va_list args = WINPR_C_ARRAY_INIT;
316
317 va_start(args, fmt);
318 const BOOL rc =
319 Stream_CheckAndLogRequiredCapacityExVa(tag, level, s, nmemb, size, fmt, args);
320 va_end(args);
321 return rc;
322 }
323 return TRUE;
324}
325
326BOOL Stream_CheckAndLogRequiredCapacityExVa(const char* tag, DWORD level, wStream* s, size_t nmemb,
327 size_t size, const char* fmt, va_list args)
328{
329 WINPR_ASSERT(size != 0);
330 const size_t actual = Stream_GetRemainingCapacity(s) / size;
331
332 if (actual < nmemb)
333 return Stream_CheckAndLogRequiredCapacityWLogExVa(WLog_Get(tag), level, s, nmemb, size, fmt,
334 args);
335 return TRUE;
336}
337
338WINPR_ATTR_FORMAT_ARG(6, 0)
339BOOL Stream_CheckAndLogRequiredCapacityWLogExVa(wLog* log, DWORD level, wStream* s, size_t nmemb,
340 size_t size, WINPR_FORMAT_ARG const char* fmt,
341 va_list args)
342{
343
344 WINPR_ASSERT(size != 0);
345 const size_t actual = Stream_GetRemainingCapacity(s) / size;
346
347 if (actual < nmemb)
348 {
349 char prefix[1024] = WINPR_C_ARRAY_INIT;
350
351 (void)vsnprintf(prefix, sizeof(prefix), fmt, args);
352
353 WLog_Print(log, level,
354 "[%s] invalid remaining capacity, got %" PRIuz ", require at least %" PRIuz
355 " [element size=%" PRIuz "]",
356 prefix, actual, nmemb, size);
357 winpr_log_backtrace_ex(log, level, 20);
358 return FALSE;
359 }
360 return TRUE;
361}
362
363WINPR_ATTR_FORMAT_ARG(6, 7)
364BOOL Stream_CheckAndLogRequiredCapacityWLogEx(wLog* log, DWORD level, wStream* s, size_t nmemb,
365 size_t size, WINPR_FORMAT_ARG const char* fmt, ...)
366{
367
368 WINPR_ASSERT(size != 0);
369 const size_t actual = Stream_GetRemainingCapacity(s) / size;
370
371 if (actual < nmemb)
372 {
373 va_list args = WINPR_C_ARRAY_INIT;
374
375 va_start(args, fmt);
376 const BOOL rc =
377 Stream_CheckAndLogRequiredCapacityWLogExVa(log, level, s, nmemb, size, fmt, args);
378 va_end(args);
379 return rc;
380 }
381 return TRUE;
382}
383
384WINPR_ATTR_FORMAT_ARG(6, 7)
385BOOL Stream_CheckAndLogRequiredLengthEx(const char* tag, DWORD level, wStream* s, size_t nmemb,
386 size_t size, WINPR_FORMAT_ARG const char* fmt, ...)
387{
388 WINPR_ASSERT(size > 0);
389 const size_t actual = Stream_GetRemainingLength(s) / size;
390
391 if (actual < nmemb)
392 {
393 va_list args = WINPR_C_ARRAY_INIT;
394
395 va_start(args, fmt);
396 const BOOL rc = Stream_CheckAndLogRequiredLengthExVa(tag, level, s, nmemb, size, fmt, args);
397 va_end(args);
398 return rc;
399 }
400 return TRUE;
401}
402
403BOOL Stream_CheckAndLogRequiredLengthExVa(const char* tag, DWORD level, wStream* s, size_t nmemb,
404 size_t size, const char* fmt, va_list args)
405{
406 WINPR_ASSERT(size > 0);
407 const size_t actual = Stream_GetRemainingLength(s) / size;
408
409 if (actual < nmemb)
410 return Stream_CheckAndLogRequiredLengthWLogExVa(WLog_Get(tag), level, s, nmemb, size, fmt,
411 args);
412 return TRUE;
413}
414
415BOOL Stream_CheckAndLogRequiredLengthWLogEx(wLog* log, DWORD level, wStream* s, size_t nmemb,
416 size_t size, const char* fmt, ...)
417{
418 WINPR_ASSERT(size > 0);
419 const size_t actual = Stream_GetRemainingLength(s) / size;
420
421 if (actual < nmemb)
422 {
423 va_list args = WINPR_C_ARRAY_INIT;
424
425 va_start(args, fmt);
426 const BOOL rc =
427 Stream_CheckAndLogRequiredLengthWLogExVa(log, level, s, nmemb, size, fmt, args);
428 va_end(args);
429 return rc;
430 }
431 return TRUE;
432}
433
434WINPR_ATTR_FORMAT_ARG(6, 0)
435BOOL Stream_CheckAndLogRequiredLengthWLogExVa(wLog* log, DWORD level, wStream* s, size_t nmemb,
436 size_t size, WINPR_FORMAT_ARG const char* fmt,
437 va_list args)
438{
439 WINPR_ASSERT(size > 0);
440 const size_t actual = Stream_GetRemainingLength(s) / size;
441
442 if (actual < nmemb)
443 {
444 char prefix[1024] = WINPR_C_ARRAY_INIT;
445
446 (void)vsnprintf(prefix, sizeof(prefix), fmt, args);
447
448 WLog_Print(log, level,
449 "[%s] invalid length, got %" PRIuz ", require at least %" PRIuz
450 " [element size=%" PRIuz "]",
451 prefix, actual, nmemb, size);
452 winpr_log_backtrace_ex(log, level, 20);
453 return FALSE;
454 }
455 return TRUE;
456}
457
458SSIZE_T Stream_Write_UTF16_String_From_UTF8(wStream* s, size_t wcharLength, const char* src,
459 size_t length, BOOL fill)
460{
461 SSIZE_T rc = 0;
462 WCHAR* str = Stream_PointerAs(s, WCHAR);
463
464 if (length != 0)
465 {
466 if (!Stream_CheckAndLogRequiredCapacityOfSize(STREAM_TAG, s, wcharLength, sizeof(WCHAR)))
467 return -1;
468
469 rc = ConvertUtf8NToWChar(src, length, str, wcharLength);
470 if (rc < 0)
471 return -1;
472
473 Stream_Seek(s, (size_t)rc * sizeof(WCHAR));
474 }
475
476 if (fill)
477 Stream_Zero(s, (wcharLength - (size_t)rc) * sizeof(WCHAR));
478 return rc;
479}
480
481char* Stream_Read_UTF16_String_As_UTF8(wStream* s, size_t wcharLength, size_t* pUtfCharLength)
482{
483 const WCHAR* str = Stream_ConstPointer(s);
484 if (wcharLength > SIZE_MAX / sizeof(WCHAR))
485 return nullptr;
486
487 if (!Stream_CheckAndLogRequiredLength(STREAM_TAG, s, wcharLength * sizeof(WCHAR)))
488 return nullptr;
489
490 Stream_Seek(s, wcharLength * sizeof(WCHAR));
491 return ConvertWCharNToUtf8Alloc(str, wcharLength, pUtfCharLength);
492}
493
494SSIZE_T Stream_Read_UTF16_String_As_UTF8_Buffer(wStream* s, size_t wcharLength, char* utfBuffer,
495 size_t utfBufferCharLength)
496{
497 const WCHAR* ptr = Stream_ConstPointer(s);
498 if (wcharLength > SIZE_MAX / sizeof(WCHAR))
499 return -1;
500
501 if (!Stream_CheckAndLogRequiredLength(STREAM_TAG, s, wcharLength * sizeof(WCHAR)))
502 return -1;
503
504 Stream_Seek(s, wcharLength * sizeof(WCHAR));
505 return ConvertWCharNToUtf8(ptr, wcharLength, utfBuffer, utfBufferCharLength);
506}
507
508BOOL Stream_SafeSeekEx(wStream* s, size_t size, const char* file, size_t line, const char* fkt)
509{
510 if (!Stream_CheckAndLogRequiredLengthEx(STREAM_TAG, WLOG_WARN, s, size, 1, "%s(%s:%" PRIuz ")",
511 fkt, file, line))
512 return FALSE;
513
514 Stream_Seek(s, size);
515 return TRUE;
516}