RTDECL(void) RTAsn1Core_Delete(PRTASN1CORE pThis)
{
if (pThis && RTASN1CORE_IS_PRESENT(pThis))
{
Assert(pThis->pOps == &g_RTAsn1Core_Vtable);
RTAsn1ContentFree(pThis);
RT_ZERO(*pThis);
}
}
RTDECL(void) RTAsn1Integer_Delete(PRTASN1INTEGER pThis)
{
if ( pThis
&& RTAsn1Integer_IsPresent(pThis))
{
Assert(pThis->Asn1Core.pOps == &g_RTAsn1Integer_Vtable);
RTAsn1ContentFree(&pThis->Asn1Core);
RT_ZERO(*pThis);
}
}
RTDECL(void) RTAsn1Time_Delete(PRTASN1TIME pThis)
{
if ( pThis
&& RTAsn1Time_IsPresent(pThis))
{
Assert(pThis->Asn1Core.pOps == &g_RTAsn1Time_Vtable);
RTAsn1ContentFree(&pThis->Asn1Core);
RT_ZERO(*pThis);
}
}
RTDECL(void) RTAsn1Boolean_Delete(PRTASN1BOOLEAN pThis)
{
if ( pThis
&& RTAsn1Boolean_IsPresent(pThis))
{
Assert(pThis->Asn1Core.pOps == &g_RTAsn1Boolean_Vtable);
Assert(pThis->Asn1Core.cb <= 1);
RTAsn1ContentFree(&pThis->Asn1Core);
RT_ZERO(*pThis);
}
}
RTDECL(int) RTAsn1Boolean_Set(PRTASN1BOOLEAN pThis, bool fValue)
{
/* Since we don't need an allocator, let's automatically initialize the struct. */
if (!RTAsn1Boolean_IsPresent(pThis))
RTAsn1Boolean_Init(pThis, NULL);
else
RTAsn1ContentFree(&pThis->Asn1Core);
pThis->fValue = fValue;
pThis->Asn1Core.uData.pv = (void *)(fValue ? &g_bTrue : &g_bFalse);
pThis->Asn1Core.cb = 1;
pThis->Asn1Core.fFlags &= ~RTASN1CORE_F_DEFAULT;
pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRESENT;
return VINF_SUCCESS;
}
RTDECL(int) RTAsn1ContentReallocZ(PRTASN1CORE pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator)
{
/* Validate input. */
AssertPtr(pAsn1Core);
AssertReturn(cb < _1G, VERR_INVALID_PARAMETER);
if (cb > 0)
{
/*
* Case 1 - Initial allocation.
*/
uint32_t cbNeeded = RT_OFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
if (!(pAsn1Core->fFlags & RTASN1CORE_F_ALLOCATED_CONTENT))
return RTAsn1ContentAllocZ(pAsn1Core, cb, pAllocator);
/* Locate the header. */
PRTASN1MEMCONTENT pHdr = RT_FROM_MEMBER(pAsn1Core->uData.pv, RTASN1MEMCONTENT, au64Content);
/*
* Case 2 - Reallocation using the same allocator.
*/
if ( pHdr->Allocation.pAllocator == pAllocator
|| !pAllocator)
{
pHdr->Allocation.cReallocs++;
/* Modify the allocation if necessary. */
if (pHdr->Allocation.cbAllocated < cbNeeded)
{
RTASN1ALLOCATION Allocation = pHdr->Allocation;
int rc = Allocation.pAllocator->pfnRealloc(Allocation.pAllocator, &Allocation, pHdr, (void **)&pHdr, cbNeeded);
if (RT_FAILURE(rc))
return rc;
Assert(Allocation.cbAllocated >= cbNeeded);
pAsn1Core->uData.pv = &pHdr->au64Content[0];
pHdr->Allocation = Allocation;
}
/* Clear any additional memory we're letting the user use and
update the content size. */
if (pAsn1Core->cb < cb)
RT_BZERO((uint8_t *)&pAsn1Core->uData.pu8[pAsn1Core->cb], cb - pAsn1Core->cb);
pAsn1Core->cb = (uint32_t)cb;
}
/*
* Case 3 - Reallocation using a different allocator.
*/
else
{
/* Initialize the temporary allocation tracker. */
RTASN1ALLOCATION Allocation;
Allocation.cbAllocated = 0;
Allocation.cReallocs = pHdr->Allocation.cReallocs + 1;
Allocation.uReserved0 = 0;
Allocation.pAllocator = pAllocator;
/* Make the allocation. */
PRTASN1MEMCONTENT pHdrNew;
int rc = pAllocator->pfnAlloc(pAllocator, &Allocation, (void **)&pHdrNew, cbNeeded);
if (RT_FAILURE(rc))
return rc;
Assert(Allocation.cbAllocated >= cbNeeded);
/* Duplicate the old content and zero any new memory we might've added. */
if (pAsn1Core->cb >= cb)
memcpy(&pHdrNew->au64Content[0], &pHdr->au64Content[0], cb);
else
{
memcpy(&pHdrNew->au64Content[0], &pHdr->au64Content[0], pAsn1Core->cb);
RT_BZERO((uint8_t *)&pHdrNew->au64Content[0] + pAsn1Core->cb, cb - pAsn1Core->cb);
}
/* Update the core. */
pHdrNew->Allocation = Allocation;
pAsn1Core->uData.pv = &pHdrNew->au64Content[0];
pAsn1Core->fFlags |= RTASN1CORE_F_ALLOCATED_CONTENT; /* free cleared it. */
pAsn1Core->cb = (uint32_t)cb;
/* Free the old content. */
Allocation = pHdr->Allocation;
Allocation.pAllocator->pfnFree(Allocation.pAllocator, &Allocation, pHdr);
Assert(Allocation.cbAllocated == 0);
}
}
/*
* Case 4 - It's a request to free the memory.
*/
else
RTAsn1ContentFree(pAsn1Core);
return VINF_SUCCESS;
}
