memory.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Spooler Router
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     Functions for allocating and freeing memory
 * COPYRIGHT:   Copyright 2015-2017 Colin Finck (colin@reactos.org)
 */

#include "precomp.h"


PVOID WINAPI
AlignRpcPtr(PVOID pBuffer, PDWORD pcbBuffer)
{
    ASSERT(pcbBuffer);

    // Align down the buffer size in pcbBuffer to a 4-byte boundary.
    *pcbBuffer -= *pcbBuffer % sizeof(DWORD);

    // Check if pBuffer is 4-byte aligned. If not, allocate a 4-byte aligned buffer.
    if ((ULONG_PTR)pBuffer % sizeof(DWORD))
        pBuffer = DllAllocSplMem(*pcbBuffer);

    return pBuffer;
}

PWSTR WINAPI
AllocSplStr(PCWSTR pwszInput)
{
    DWORD cbInput;
    PWSTR pwszOutput;

    // Sanity check
    if (!pwszInput)
        return NULL;

    // Get the length of the input string.
    cbInput = (wcslen(pwszInput) + 1) * sizeof(WCHAR);

    // Allocate it. We don't use DllAllocSplMem here, because it unnecessarily zeroes the memory.
    pwszOutput = HeapAlloc(hProcessHeap, 0, cbInput);
    if (!pwszOutput)
    {
        ERR("HeapAlloc failed!\n");
        return NULL;
    }

    // Copy the string and return it.
    CopyMemory(pwszOutput, pwszInput, cbInput);
    return pwszOutput;
}

PVOID WINAPI
DllAllocSplMem(DWORD dwBytes)
{
    return HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, dwBytes);
}

BOOL WINAPI
DllFreeSplMem(PVOID pMem)
{
    return HeapFree(hProcessHeap, 0, pMem);
}

BOOL WINAPI
DllFreeSplStr(PWSTR pwszString)
{
    return HeapFree(hProcessHeap, 0, pwszString);
}

PVOID WINAPI
ReallocSplMem(PVOID pOldMem, DWORD cbOld, DWORD cbNew)
{
    PVOID pNewMem;

    // Always allocate the new block of memory.
    pNewMem = DllAllocSplMem(cbNew);
    if (!pNewMem)
    {
        ERR("DllAllocSplMem failed!\n");
        return NULL;
    }

    // Copy the old memory into the new block and free it.
    if (pOldMem)
    {
        CopyMemory(pNewMem, pOldMem, min(cbOld, cbNew));
        DllFreeSplMem(pOldMem);
    }

    return pNewMem;
}

BOOL WINAPI
ReallocSplStr(PWSTR* ppwszString, PCWSTR pwszInput)
{
    if (*ppwszString)
        DllFreeSplStr(*ppwszString);

    *ppwszString = AllocSplStr(pwszInput);

    return TRUE;
}

PDWORD WINAPI
UndoAlignRpcPtr(PVOID pDestinationBuffer, PVOID pSourceBuffer, DWORD cbBuffer, PDWORD pcbNeeded)
{
    // pDestinationBuffer is accessed unless pSourceBuffer equals pDestinationBuffer or cbBuffer is 0.
    ASSERT(pDestinationBuffer || pSourceBuffer == pDestinationBuffer || cbBuffer == 0);

    // If pSourceBuffer is given, and source and destination pointers don't match,
    // we assume that pSourceBuffer is the buffer allocated by AlignRpcPtr.
    if (pSourceBuffer && pSourceBuffer != pDestinationBuffer)
    {
        // Copy back the buffer data to the (usually unaligned) destination buffer
        // and free the buffer allocated by AlignRpcPtr.
        CopyMemory(pDestinationBuffer, pSourceBuffer, cbBuffer);
        DllFreeSplMem(pSourceBuffer);
    }

    // If pcbNeeded is given, align it up to a 4-byte boundary.
    if (pcbNeeded && *pcbNeeded % sizeof(DWORD))
        *pcbNeeded += sizeof(DWORD) - *pcbNeeded % sizeof(DWORD);

    return pcbNeeded;
}