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