720 lines
20 KiB
C++
720 lines
20 KiB
C++
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||
|
||
Copyright (c) 1993 Microsoft Corporation
|
||
|
||
Module Name :
|
||
|
||
fullptr.c
|
||
|
||
Abstract :
|
||
|
||
This file contains the APIs for handling full pointers in the NDR engine
|
||
and inlined stubs for MIDL 2.0.
|
||
|
||
Author :
|
||
|
||
David Kays dkays January 1994.
|
||
|
||
Revision History :
|
||
|
||
---------------------------------------------------------------------*/
|
||
|
||
#include "ndrp.h"
|
||
|
||
static void
|
||
NdrFullPointerXlatRealloc ( PFULL_PTR_XLAT_TABLES pXlatTables, ulong RefId );
|
||
|
||
|
||
PFULL_PTR_XLAT_TABLES RPC_ENTRY
|
||
NdrFullPointerXlatInit(
|
||
ulong NumberOfPointers,
|
||
XLAT_SIDE XlatSide )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
Allocates full pointer support data structures for an RPC call.
|
||
|
||
Arguments :
|
||
|
||
NumberOfPointer - If possible, the stub passes in the total number
|
||
of possible full pointers that will be used during a call.
|
||
|
||
Return value :
|
||
|
||
A pointer to the full pointer translations tables used during an rpc call.
|
||
|
||
***/
|
||
{
|
||
PFULL_PTR_XLAT_TABLES pXlatTables;
|
||
uint RefIdToPointerEntries;
|
||
uint PointerToRefIdBuckets;
|
||
BOOL fOutOfMemory = FALSE;
|
||
|
||
pXlatTables = (PFULL_PTR_XLAT_TABLES)
|
||
I_RpcAllocate(sizeof(FULL_PTR_XLAT_TABLES));
|
||
|
||
// Because old compilers didn't initialize the xlat ptr in stubmsg
|
||
// at the client in Os mode, we cannot raise exception right away.
|
||
|
||
if ( ! pXlatTables )
|
||
fOutOfMemory = TRUE;
|
||
else
|
||
{
|
||
//
|
||
// Determine the size of both translation tables.
|
||
//
|
||
if ( NumberOfPointers )
|
||
{
|
||
ulong Shift, Bitmask;
|
||
|
||
RefIdToPointerEntries = (uint) NumberOfPointers;
|
||
|
||
//
|
||
// Find the smallest power of 2 which is greater than
|
||
// RefIdToPointerEntries.
|
||
//
|
||
for ( Shift = 0, Bitmask = 0x80000000;
|
||
! (Bitmask & (ulong) RefIdToPointerEntries);
|
||
Shift++, Bitmask >>= 1 )
|
||
;
|
||
|
||
PointerToRefIdBuckets = (uint)((0xffffffff >> Shift) + 1);
|
||
}
|
||
else
|
||
{
|
||
RefIdToPointerEntries = DEFAULT_REF_ID_TO_POINTER_TABLE_ELEMENTS;
|
||
PointerToRefIdBuckets = DEFAULT_POINTER_TO_REF_ID_TABLE_BUCKETS;
|
||
}
|
||
|
||
// Make sure we can clean up correctly later if case of an exception.
|
||
|
||
pXlatTables->RefIdToPointer.XlatTable = 0;
|
||
pXlatTables->RefIdToPointer.StateTable = 0;
|
||
pXlatTables->PointerToRefId.XlatTable = 0;
|
||
pXlatTables->RefIdToPointer.NumberOfEntries = 0;
|
||
pXlatTables->PointerToRefId.NumberOfBuckets = 0;
|
||
|
||
//
|
||
// Initialize the ref id to pointer tables.
|
||
//
|
||
pXlatTables->RefIdToPointer.XlatTable =
|
||
(void **) I_RpcAllocate( RefIdToPointerEntries * sizeof(void *) );
|
||
|
||
if ( ! pXlatTables->RefIdToPointer.XlatTable )
|
||
fOutOfMemory = TRUE;
|
||
else
|
||
{
|
||
MIDL_memset( pXlatTables->RefIdToPointer.XlatTable,
|
||
0,
|
||
RefIdToPointerEntries * sizeof(void *) );
|
||
|
||
pXlatTables->RefIdToPointer.StateTable =
|
||
(uchar *) I_RpcAllocate( RefIdToPointerEntries * sizeof(uchar) );
|
||
|
||
if ( ! pXlatTables->RefIdToPointer.StateTable )
|
||
fOutOfMemory = TRUE;
|
||
else
|
||
{
|
||
MIDL_memset( pXlatTables->RefIdToPointer.StateTable,
|
||
0,
|
||
RefIdToPointerEntries * sizeof(uchar) );
|
||
|
||
pXlatTables->RefIdToPointer.NumberOfEntries = RefIdToPointerEntries;
|
||
|
||
//
|
||
// Intialize the pointer to ref id tables.
|
||
//
|
||
pXlatTables->PointerToRefId.XlatTable =
|
||
(PFULL_PTR_TO_REFID_ELEMENT *)
|
||
I_RpcAllocate( PointerToRefIdBuckets *
|
||
sizeof(PFULL_PTR_TO_REFID_ELEMENT) );
|
||
|
||
if ( ! pXlatTables->PointerToRefId.XlatTable )
|
||
fOutOfMemory = TRUE;
|
||
else
|
||
{
|
||
MIDL_memset( pXlatTables->PointerToRefId.XlatTable,
|
||
0,
|
||
PointerToRefIdBuckets * sizeof(PFULL_PTR_TO_REFID_ELEMENT) );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if ( fOutOfMemory )
|
||
{
|
||
NdrFullPointerXlatFree( pXlatTables );
|
||
|
||
if ( XlatSide == XLAT_SERVER )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
else
|
||
{
|
||
// The old compilers generate a code for the client side that
|
||
// doesn't initialize the table pointer and the stub msg
|
||
// initialization is after call to xlat initialize.
|
||
// So, we are down to checking the pointer when used.
|
||
|
||
return( 0 );
|
||
}
|
||
}
|
||
|
||
pXlatTables->PointerToRefId.NumberOfBuckets = PointerToRefIdBuckets;
|
||
pXlatTables->PointerToRefId.HashMask = PointerToRefIdBuckets - 1;
|
||
|
||
pXlatTables->NextRefId = 1;
|
||
|
||
pXlatTables->XlatSide = XlatSide;
|
||
|
||
return pXlatTables;
|
||
}
|
||
|
||
|
||
void RPC_ENTRY
|
||
NdrFullPointerXlatFree(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
Free the full pointer support data structures for an rpc call.
|
||
|
||
Arguments :
|
||
|
||
pXlatTables - Full pointer translation tables data structure to free.
|
||
|
||
***/
|
||
{
|
||
PFULL_PTR_TO_REFID_ELEMENT * HashTable;
|
||
PFULL_PTR_TO_REFID_ELEMENT pElement, pTemp;
|
||
ulong Buckets;
|
||
ulong i;
|
||
|
||
if ( ! pXlatTables )
|
||
return;
|
||
|
||
//
|
||
// Free the ref id to pointer tables.
|
||
//
|
||
if ( pXlatTables->RefIdToPointer.XlatTable )
|
||
I_RpcFree( pXlatTables->RefIdToPointer.XlatTable );
|
||
|
||
if ( pXlatTables->RefIdToPointer.StateTable )
|
||
I_RpcFree( pXlatTables->RefIdToPointer.StateTable );
|
||
|
||
//
|
||
// Free the pointer to ref id table.
|
||
//
|
||
HashTable = pXlatTables->PointerToRefId.XlatTable;
|
||
|
||
if ( HashTable )
|
||
{
|
||
Buckets = pXlatTables->PointerToRefId.NumberOfBuckets;
|
||
|
||
for ( i = 0; i < Buckets; i++ )
|
||
if ( HashTable[i] )
|
||
for ( pElement = HashTable[i]; pElement; pElement = pTemp )
|
||
{
|
||
pTemp = pElement->Next;
|
||
|
||
I_RpcFree(pElement);
|
||
}
|
||
|
||
I_RpcFree( HashTable );
|
||
}
|
||
|
||
//
|
||
// Free the translation table structure.
|
||
//
|
||
I_RpcFree( pXlatTables );
|
||
}
|
||
|
||
|
||
int RPC_ENTRY
|
||
NdrFullPointerQueryPointer(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables,
|
||
void * pPointer,
|
||
uchar QueryType,
|
||
ulong * pRefId )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
This routine checks if a full pointer is in the full pointer translation
|
||
table and is marked with the given state.
|
||
|
||
If there is no current translation for this pointer then a translation is
|
||
inserted in the given translation table and a ref id is assigned if pRefId
|
||
is non-null.
|
||
|
||
Arguments :
|
||
|
||
pXlatTable - The full pointer translation tables.
|
||
pPointer - The pointer to check.
|
||
QueryType - The type of query, either FULL_POINTER_MARSHALLED or
|
||
FULL_POINTER_BUF_SIZED.
|
||
pRefId - The ref id for the pointer is returned if this parameter
|
||
is non-null.
|
||
|
||
Return Value :
|
||
|
||
TRUE if the given pointer was null or a translation for the full pointer
|
||
was found and had the QueryType set, FALSE otherwise.
|
||
|
||
A return value of FALSE indicates that the pointee should be sized or
|
||
marshalled.
|
||
|
||
***/
|
||
{
|
||
PFULL_PTR_TO_REFID_ELEMENT * HashTable;
|
||
PFULL_PTR_TO_REFID_ELEMENT pElement;
|
||
ulong HashTableIndex;
|
||
|
||
if ( ! pPointer )
|
||
{
|
||
if ( pRefId )
|
||
*pRefId = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
if ( ! pXlatTables )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
HashTable = pXlatTables->PointerToRefId.XlatTable;
|
||
|
||
//
|
||
// Lookup pPointer in PointerToRefId table.
|
||
//
|
||
|
||
HashTableIndex = PTR_HASH( pPointer, pXlatTables->PointerToRefId.HashMask );
|
||
|
||
for ( pElement = HashTable[HashTableIndex];
|
||
pElement;
|
||
pElement = pElement->Next )
|
||
{
|
||
if ( pElement->Pointer == pPointer )
|
||
{
|
||
if ( CHECK_FULL_POINTER_STATE( pElement->State, QueryType ) )
|
||
{
|
||
if ( pRefId )
|
||
*pRefId = pElement->RefId;
|
||
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Assign a ref id now if it doesn't have one and pRefId is
|
||
// non null.
|
||
//
|
||
if ( pRefId && ! pElement->RefId )
|
||
pElement->RefId = pXlatTables->NextRefId++;
|
||
|
||
SET_FULL_POINTER_STATE( pElement->State, QueryType );
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// If there is no translation for the pointer then insert a new one.
|
||
//
|
||
if ( ! pElement )
|
||
{
|
||
pElement = (PFULL_PTR_TO_REFID_ELEMENT)
|
||
I_RpcAllocate( sizeof(FULL_PTR_TO_REFID_ELEMENT) );
|
||
|
||
if ( ! pElement )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
pElement->State = 0;
|
||
|
||
SET_FULL_POINTER_STATE( pElement->State, QueryType );
|
||
|
||
pElement->Pointer = pPointer;
|
||
|
||
if ( pRefId )
|
||
pElement->RefId = pXlatTables->NextRefId++;
|
||
else
|
||
pElement->RefId = 0;
|
||
|
||
pElement->Next = HashTable[HashTableIndex];
|
||
HashTable[HashTableIndex] = pElement;
|
||
}
|
||
|
||
//
|
||
// Set the ref id return value.
|
||
//
|
||
if ( pRefId )
|
||
{
|
||
//
|
||
// We get here the first time we marshall a new full pointer.
|
||
//
|
||
*pRefId = pElement->RefId;
|
||
|
||
//
|
||
// We insert the reverse translation if we're on the client side.
|
||
//
|
||
if ( pXlatTables->XlatSide == XLAT_CLIENT )
|
||
{
|
||
if ( *pRefId >= pXlatTables->RefIdToPointer.NumberOfEntries )
|
||
NdrFullPointerXlatRealloc( pXlatTables, *pRefId );
|
||
|
||
pXlatTables->RefIdToPointer.XlatTable[*pRefId] = pPointer;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
int RPC_ENTRY
|
||
NdrFullPointerQueryRefId(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables,
|
||
ulong RefId,
|
||
uchar QueryType,
|
||
void ** ppPointer )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
This routine checks if a ref id is in the full pointer translation table
|
||
and is marked with the given state.
|
||
|
||
If a translation is found and ppPointer is non-null then *ppPointer is set
|
||
to the value of the ref id's pointer value.
|
||
|
||
If this routine returns FALSE for a FULL_POINTER_UNMARSHALLED query then
|
||
the full pointer should be allocated and a call to
|
||
NdrFullPointerInsertRefId must be made.
|
||
|
||
If this routine returns FALSE for a FULL_POINTER_MEM_SIZED query then
|
||
the size of the full pointer's pointee should be added to the current
|
||
memory sizing calculation.
|
||
|
||
Arguments :
|
||
|
||
pXlatTable - The full pointer translation tables.
|
||
pRefId - The ref id to search for.
|
||
QueryType - The type of query, either FULL_POINTER_UNMARSHALLED or
|
||
FULL_POINTER_MEM_SIZED.
|
||
ppPointer - Holds the returned pointer value for the ref id if it is
|
||
found.
|
||
|
||
Return Value :
|
||
|
||
TRUE if the ref id is 0 or a translation for the ref id is found and had
|
||
the QueryType set, FALSE otherwise.
|
||
|
||
A return value of FALSE indicates that the pointee should be sized or
|
||
unmarshalled.
|
||
|
||
***/
|
||
{
|
||
uchar * StateTable;
|
||
void * Pointer;
|
||
|
||
if ( ! RefId )
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
if ( ! pXlatTables )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
if ( RefId >= pXlatTables->NextRefId )
|
||
pXlatTables->NextRefId = RefId + 1;
|
||
|
||
if ( RefId >= pXlatTables->RefIdToPointer.NumberOfEntries )
|
||
NdrFullPointerXlatRealloc( pXlatTables, RefId );
|
||
|
||
StateTable = pXlatTables->RefIdToPointer.StateTable;
|
||
|
||
Pointer = pXlatTables->RefIdToPointer.XlatTable[RefId];
|
||
|
||
//
|
||
// We make this check first. It's possible that we will already have
|
||
// a translation for the ref id, but it simply won't be marked yet with
|
||
// the proper state. In this case we still want to return the correct
|
||
// pointer value from the translation tables, but we'll still end up
|
||
// returning false when we make the state check.
|
||
//
|
||
if ( ppPointer )
|
||
{
|
||
//
|
||
// We have to make sure and always copy the pointer's value from
|
||
// the table. This way we handle the case when a pointer's VALUE
|
||
// changes to a pointer which has a currently valid RefId (an
|
||
// example of this could happen when a server swaps the values of
|
||
// two [in,out] double pointers).
|
||
//
|
||
// Pointer will be null if this is the first time we've seen or used
|
||
// this ref id.
|
||
//
|
||
*ppPointer = Pointer;
|
||
}
|
||
|
||
if ( CHECK_FULL_POINTER_STATE( StateTable[RefId], QueryType ) )
|
||
{
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
SET_FULL_POINTER_STATE( StateTable[RefId], QueryType );
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
void RPC_ENTRY
|
||
NdrFullPointerInsertRefId(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables,
|
||
ulong RefId,
|
||
void * pPointer )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
This routine inserts a ref id to pointer translation in the full pointer
|
||
translation table.
|
||
|
||
Arguments :
|
||
|
||
pXlatTable - The full pointer translation tables.
|
||
pRefId - The ref id.
|
||
pPointer - The pointer.
|
||
|
||
Return Value :
|
||
|
||
None.
|
||
|
||
***/
|
||
{
|
||
// unused: uchar * StateTable;
|
||
|
||
if ( ! pXlatTables )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
//
|
||
// Ref id should be non-zero.
|
||
//
|
||
NDR_ASSERT( RefId, "NdrFullPointerInsertRefId : Ref id is zero" );
|
||
|
||
//
|
||
// Ref id should fit in the current table.
|
||
//
|
||
NDR_ASSERT( RefId < pXlatTables->RefIdToPointer.NumberOfEntries,
|
||
"NdrFullPointerInsertRefId : Ref Id too large" );
|
||
|
||
//
|
||
// There should currently be no pointer translation for this ref id.
|
||
//
|
||
NDR_ASSERT( ! pXlatTables->RefIdToPointer.XlatTable[RefId],
|
||
"NdrFullPointerInsertRefId : Translation already exists" );
|
||
|
||
//
|
||
// Insert the translation.
|
||
//
|
||
pXlatTables->RefIdToPointer.XlatTable[RefId] = pPointer;
|
||
|
||
//
|
||
// If we're on the server side then insert the inverse translation.
|
||
//
|
||
if ( pXlatTables->XlatSide == XLAT_SERVER )
|
||
{
|
||
PFULL_PTR_TO_REFID_ELEMENT pElement;
|
||
long HashTableIndex;
|
||
|
||
pElement = (PFULL_PTR_TO_REFID_ELEMENT)
|
||
I_RpcAllocate( sizeof(FULL_PTR_TO_REFID_ELEMENT) );
|
||
|
||
if ( ! pElement )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
pElement->State = 0;
|
||
pElement->Pointer = pPointer;
|
||
pElement->RefId = RefId;
|
||
|
||
HashTableIndex = PTR_HASH( pPointer,
|
||
pXlatTables->PointerToRefId.HashMask );
|
||
|
||
pElement->Next = pXlatTables->PointerToRefId.XlatTable[HashTableIndex];
|
||
pXlatTables->PointerToRefId.XlatTable[HashTableIndex] = pElement;
|
||
}
|
||
}
|
||
|
||
|
||
int RPC_ENTRY
|
||
NdrFullPointerFree(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables,
|
||
void * pPointer )
|
||
/***
|
||
|
||
Routine description :
|
||
|
||
Removes a full pointer from the translation tables, and frees it's
|
||
associated translation data.
|
||
|
||
Return value :
|
||
|
||
TRUE if the pointer has not yet been freed or is null, FALSE otherwise.
|
||
|
||
***/
|
||
{
|
||
PFULL_PTR_TO_REFID_ELEMENT * HashTable;
|
||
PFULL_PTR_TO_REFID_ELEMENT pElement;
|
||
ulong HashTableIndex;
|
||
|
||
if ( ! pPointer )
|
||
return FALSE;
|
||
|
||
if ( ! pXlatTables )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
HashTable = pXlatTables->PointerToRefId.XlatTable;
|
||
|
||
//
|
||
// Lookup pPointer in PointerToRefId table.
|
||
//
|
||
|
||
HashTableIndex = PTR_HASH( pPointer, pXlatTables->PointerToRefId.HashMask );
|
||
|
||
for ( pElement = HashTable[HashTableIndex];
|
||
pElement;
|
||
pElement = pElement->Next )
|
||
{
|
||
if ( pElement->Pointer == pPointer )
|
||
{
|
||
if ( CHECK_FULL_POINTER_STATE(pElement->State,FULL_POINTER_FREED) )
|
||
{
|
||
return FALSE;
|
||
}
|
||
else
|
||
{
|
||
SET_FULL_POINTER_STATE(pElement->State,FULL_POINTER_FREED);
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// There is an instance when a full pointer is encountered for the first
|
||
// time during freeing. This occurs if an [in] full pointer is changed
|
||
// by the server manager routine. If this occurs we must insert the new
|
||
// full pointer so we can keep track of it so that we don't free it more
|
||
// than once.
|
||
//
|
||
|
||
pElement = (PFULL_PTR_TO_REFID_ELEMENT)
|
||
I_RpcAllocate( sizeof(FULL_PTR_TO_REFID_ELEMENT) );
|
||
|
||
if ( ! pElement )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
pElement->State = 0;
|
||
pElement->Pointer = pPointer;
|
||
|
||
HashTableIndex = PTR_HASH( pPointer,
|
||
pXlatTables->PointerToRefId.HashMask );
|
||
|
||
pElement->Next = pXlatTables->PointerToRefId.XlatTable[HashTableIndex];
|
||
pXlatTables->PointerToRefId.XlatTable[HashTableIndex] = pElement;
|
||
|
||
SET_FULL_POINTER_STATE( pElement->State, FULL_POINTER_FREED );
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
static void
|
||
NdrFullPointerXlatRealloc(
|
||
PFULL_PTR_XLAT_TABLES pXlatTables,
|
||
ulong RefId)
|
||
{
|
||
void * pMemory;
|
||
uint Entries;
|
||
|
||
if ( ! pXlatTables )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
Entries = (uint) pXlatTables->RefIdToPointer.NumberOfEntries;
|
||
|
||
// If the number is much larger than the previous one, most likely the
|
||
// number is invalid. Before we have a concrete solution to replace the
|
||
// current fixed array of RefIdToPointer lookup, this can catch most
|
||
// of the failures.
|
||
if ( RefId >= 2 * Entries )
|
||
RpcRaiseException( RPC_X_BAD_STUB_DATA );
|
||
//
|
||
// Realloc RefIdToPointerTable. Allocate twice as many entries.
|
||
//
|
||
pMemory = I_RpcAllocate( Entries * sizeof(void *) * 2 );
|
||
|
||
if ( ! pMemory )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
//
|
||
// Now copy the current entries into the new memory.
|
||
//
|
||
RpcpMemoryCopy( pMemory,
|
||
pXlatTables->RefIdToPointer.XlatTable,
|
||
Entries * sizeof( void * ) );
|
||
|
||
//
|
||
// Set the new entries to 0.
|
||
//
|
||
MIDL_memset( (char *) pMemory + Entries * sizeof( void *),
|
||
0,
|
||
Entries * sizeof( void *) );
|
||
|
||
//
|
||
// Free the old table.
|
||
//
|
||
I_RpcFree( pXlatTables->RefIdToPointer.XlatTable );
|
||
|
||
//
|
||
// Get the new table.
|
||
//
|
||
pXlatTables->RefIdToPointer.XlatTable = (void**)pMemory;
|
||
|
||
//
|
||
// Realloc RefIdToPointerState
|
||
//
|
||
pMemory = I_RpcAllocate( Entries * sizeof(uchar) * 2 );
|
||
|
||
if ( ! pMemory )
|
||
RpcRaiseException( RPC_S_OUT_OF_MEMORY );
|
||
|
||
//
|
||
// Now copy the current entries into the new memory.
|
||
//
|
||
RpcpMemoryCopy( pMemory,
|
||
pXlatTables->RefIdToPointer.StateTable,
|
||
Entries * sizeof(uchar) );
|
||
|
||
//
|
||
// Set the new entries to 0.
|
||
//
|
||
MIDL_memset( (char *) pMemory + Entries * sizeof(uchar),
|
||
0,
|
||
Entries * sizeof(uchar) );
|
||
|
||
//
|
||
// Free the old table.
|
||
//
|
||
I_RpcFree( pXlatTables->RefIdToPointer.StateTable );
|
||
|
||
//
|
||
// Get the new table.
|
||
//
|
||
pXlatTables->RefIdToPointer.StateTable = (uchar*)pMemory;
|
||
|
||
//
|
||
// Update number of entries.
|
||
//
|
||
pXlatTables->RefIdToPointer.NumberOfEntries *= 2;
|
||
}
|
||
|