ksmith/orbithub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Milestone 5: deliver embedded RDP sessions and lifecycle hardening

Browse Source
This commit is contained in:
Keith Smith
2026-03-03 18:59:26 -07:00
parent 230a401386
commit 36006bd4aa
2941 changed files with 724359 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

311
third_party/FreeRDP/libfreerdp/utils/ringbuffer.c vendored Normal file
View File

@@ -0,0 +1,311 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
*
* Copyright 2014 Thincast Technologies GmbH
* Copyright 2014 Hardening <contact@hardening-consulting.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.
*/
#include <freerdp/config.h>
#include <freerdp/utils/ringbuffer.h>
#include <stdlib.h>
#include <string.h>
#include <winpr/assert.h>
#include <winpr/crt.h>
#include <freerdp/log.h>
#ifdef WITH_DEBUG_RINGBUFFER
#define TAG FREERDP_TAG("utils.ringbuffer")
#define DEBUG_RINGBUFFER(...) WLog_DBG(TAG, __VA_ARGS__)
#else
#define DEBUG_RINGBUFFER(...) \
do \
{ \
} while (0)
#endif
BOOL ringbuffer_init(RingBuffer* ringbuffer, size_t initialSize)
{
WINPR_ASSERT(ringbuffer);
ringbuffer->buffer = malloc(initialSize);
if (!ringbuffer->buffer)
return FALSE;
ringbuffer->readPtr = ringbuffer->writePtr = 0;
ringbuffer->initialSize = ringbuffer->size = ringbuffer->freeSize = initialSize;
DEBUG_RINGBUFFER("ringbuffer_init(%p)", (void*)rb);
return TRUE;
}
size_t ringbuffer_used(const RingBuffer* ringbuffer)
{
WINPR_ASSERT(ringbuffer);
return ringbuffer->size - ringbuffer->freeSize;
}
size_t ringbuffer_capacity(const RingBuffer* ringbuffer)
{
WINPR_ASSERT(ringbuffer);
return ringbuffer->size;
}
void ringbuffer_destroy(RingBuffer* ringbuffer)
{
DEBUG_RINGBUFFER("ringbuffer_destroy(%p)", (void*)ringbuffer);
if (!ringbuffer)
return;
free(ringbuffer->buffer);
ringbuffer->buffer = nullptr;
}
static BOOL ringbuffer_realloc(RingBuffer* ringbuffer, size_t targetSize)
{
WINPR_ASSERT(ringbuffer);
BYTE* newData = nullptr;
DEBUG_RINGBUFFER("ringbuffer_realloc(%p): targetSize: %" PRIdz "", (void*)rb, targetSize);
if (ringbuffer->writePtr == ringbuffer->readPtr)
{
/* when no size is used we can realloc() and set the heads at the
* beginning of the buffer
*/
newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
if (!newData)
return FALSE;
ringbuffer->readPtr = ringbuffer->writePtr = 0;
ringbuffer->buffer = newData;
}
else if ((ringbuffer->writePtr >= ringbuffer->readPtr) && (ringbuffer->writePtr < targetSize))
{
/* we reallocate only if we're in that case, realloc don't touch read
* and write heads
*
* readPtr writePtr
* | |
* v v
* [............|XXXXXXXXXXXXXX|..........]
*/
newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
if (!newData)
return FALSE;
ringbuffer->buffer = newData;
}
else
{
/* in case of malloc the read head is moved at the beginning of the new buffer
* and the write head is set accordingly
*/
newData = (BYTE*)malloc(targetSize);
if (!newData)
return FALSE;
if (ringbuffer->readPtr < ringbuffer->writePtr)
{
/* readPtr writePtr
* | |
* v v
* [............|XXXXXXXXXXXXXX|..........]
*/
memcpy(newData, ringbuffer->buffer + ringbuffer->readPtr, ringbuffer_used(ringbuffer));
}
else
{
/* writePtr readPtr
* | |
* v v
* [XXXXXXXXXXXX|..............|XXXXXXXXXX]
*/
BYTE* dst = newData;
memcpy(dst, ringbuffer->buffer + ringbuffer->readPtr,
ringbuffer->size - ringbuffer->readPtr);
dst += (ringbuffer->size - ringbuffer->readPtr);
if (ringbuffer->writePtr)
memcpy(dst, ringbuffer->buffer, ringbuffer->writePtr);
}
ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
ringbuffer->readPtr = 0;
free(ringbuffer->buffer);
ringbuffer->buffer = newData;
}
ringbuffer->freeSize += (targetSize - ringbuffer->size);
ringbuffer->size = targetSize;
return TRUE;
}
/**
* Write to a ringbuffer
*
* @param ringbuffer A pointer to the ringbuffer
* @param ptr A pointer to the data to write
* @param sz The number of bytes to write
*
* @return \b TRUE for success, \b FALSE for failure
*/
BOOL ringbuffer_write(RingBuffer* ringbuffer, const BYTE* ptr, size_t sz)
{
size_t toWrite = 0;
size_t remaining = 0;
WINPR_ASSERT(ringbuffer);
DEBUG_RINGBUFFER("ringbuffer_write(%p): sz: %" PRIdz "", (void*)rb, sz);
if ((ringbuffer->freeSize <= sz) && !ringbuffer_realloc(ringbuffer, ringbuffer->size + sz))
return FALSE;
/* the write could be split in two
* readHead writeHead
* | |
* v v
* [ ################ ]
*/
toWrite = sz;
remaining = sz;
if (ringbuffer->size - ringbuffer->writePtr < sz)
toWrite = ringbuffer->size - ringbuffer->writePtr;
if (toWrite)
{
memcpy(ringbuffer->buffer + ringbuffer->writePtr, ptr, toWrite);
remaining -= toWrite;
ptr += toWrite;
}
if (remaining)
memcpy(ringbuffer->buffer, ptr, remaining);
ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
ringbuffer->freeSize -= sz;
return TRUE;
}
BYTE* ringbuffer_ensure_linear_write(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_ensure_linear_write(%p): sz: %" PRIdz "", (void*)rb, sz);
WINPR_ASSERT(ringbuffer);
if (ringbuffer->freeSize < sz)
{
if (!ringbuffer_realloc(ringbuffer, ringbuffer->size + sz - ringbuffer->freeSize + 32))
return nullptr;
}
if (ringbuffer->writePtr == ringbuffer->readPtr)
{
ringbuffer->writePtr = ringbuffer->readPtr = 0;
}
if (ringbuffer->writePtr + sz < ringbuffer->size)
return ringbuffer->buffer + ringbuffer->writePtr;
/*
* to add: .......
* [ XXXXXXXXX ]
*
* result:
* [XXXXXXXXX....... ]
*/
memmove(ringbuffer->buffer, ringbuffer->buffer + ringbuffer->readPtr,
ringbuffer->writePtr - ringbuffer->readPtr);
ringbuffer->readPtr = 0;
ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
return ringbuffer->buffer + ringbuffer->writePtr;
}
BOOL ringbuffer_commit_written_bytes(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_commit_written_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return TRUE;
if (ringbuffer->writePtr + sz > ringbuffer->size)
return FALSE;
ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
ringbuffer->freeSize -= sz;
return TRUE;
}
int ringbuffer_peek(const RingBuffer* ringbuffer, DataChunk chunks[2], size_t sz)
{
size_t remaining = sz;
size_t toRead = 0;
int chunkIndex = 0;
int status = 0;
DEBUG_RINGBUFFER("ringbuffer_peek(%p): sz: %" PRIdz "", (const void*)rb, sz);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return 0;
if ((ringbuffer->size - ringbuffer->freeSize) < sz)
remaining = ringbuffer->size - ringbuffer->freeSize;
toRead = remaining;
if ((ringbuffer->readPtr + remaining) > ringbuffer->size)
toRead = ringbuffer->size - ringbuffer->readPtr;
if (toRead)
{
chunks[0].data = ringbuffer->buffer + ringbuffer->readPtr;
chunks[0].size = toRead;
remaining -= toRead;
chunkIndex++;
status++;
}
if (remaining)
{
chunks[chunkIndex].data = ringbuffer->buffer;
chunks[chunkIndex].size = remaining;
status++;
}
return status;
}
void ringbuffer_commit_read_bytes(RingBuffer* ringbuffer, size_t sz)
{
DEBUG_RINGBUFFER("ringbuffer_commit_read_bytes(%p): sz: %" PRIdz "", (void*)ringbuffer, sz);
WINPR_ASSERT(ringbuffer);
if (sz < 1)
return;
WINPR_ASSERT(ringbuffer->size - ringbuffer->freeSize >= sz);
ringbuffer->readPtr = (ringbuffer->readPtr + sz) % ringbuffer->size;
ringbuffer->freeSize += sz;
/* when we reach a reasonable free size, we can go back to the original size */
if ((ringbuffer->size != ringbuffer->initialSize) &&
(ringbuffer_used(ringbuffer) < ringbuffer->initialSize / 2))
ringbuffer_realloc(ringbuffer, ringbuffer->initialSize);
}