ndr_fullpointer.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "rpc.h"
#include "rpcndr.h"
#include "wine/debug.h"

Include dependency graph for ndr_fullpointer.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (rpc)
PFULL_PTR_XLAT_TABLES WINAPI	NdrFullPointerXlatInit (ULONG NumberOfPointers, XLAT_SIDE XlatSide)
void WINAPI	NdrFullPointerXlatFree (PFULL_PTR_XLAT_TABLES pXlatTables)
static void	expand_pointer_table_if_necessary (PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId)
int WINAPI	NdrFullPointerQueryPointer (PFULL_PTR_XLAT_TABLES pXlatTables, void *pPointer, unsigned char QueryType, ULONG *pRefId)
int WINAPI	NdrFullPointerQueryRefId (PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, unsigned char QueryType, void **ppPointer)
void WINAPI	NdrFullPointerInsertRefId (PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, void *pPointer)
int WINAPI	NdrFullPointerFree (PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)

Function Documentation

expand_pointer_table_if_necessary()

static void expand_pointer_table_if_necessary ( PFULL_PTR_XLAT_TABLES  pXlatTables, ULONG  RefId  )

static

Definition at line 90 of file ndr_fullpointer.c.

{
    if (RefId >= pXlatTables->RefIdToPointer.NumberOfEntries)
    {
        pXlatTables->RefIdToPointer.NumberOfEntries = RefId * 2;
        pXlatTables->RefIdToPointer.XlatTable =
            HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                pXlatTables->RefIdToPointer.XlatTable,
                sizeof(void *) * pXlatTables->RefIdToPointer.NumberOfEntries);
        pXlatTables->RefIdToPointer.StateTable =
            HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                pXlatTables->RefIdToPointer.StateTable,
                sizeof(unsigned char) * pXlatTables->RefIdToPointer.NumberOfEntries);
 
        if (!pXlatTables->RefIdToPointer.XlatTable || !pXlatTables->RefIdToPointer.StateTable)
            pXlatTables->RefIdToPointer.NumberOfEntries = 0;
    }
}

Referenced by NdrFullPointerInsertRefId(), NdrFullPointerQueryPointer(), and NdrFullPointerQueryRefId().

NdrFullPointerFree()

int WINAPI NdrFullPointerFree	(	PFULL_PTR_XLAT_TABLES	pXlatTables,
		void *	Pointer
	)

Definition at line 214 of file ndr_fullpointer.c.

{
    ULONG Hash = 0;
    unsigned int i;
    PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
    ULONG RefId = 0;
 
    TRACE("(%p, %p)\n", pXlatTables, Pointer);
 
    if (!Pointer)
        return 1;
 
    /* simple hashing algorithm, don't know whether it matches native */
    for (i = 0; i < sizeof(Pointer); i++)
        Hash = (Hash * 3) ^ ((unsigned char *)&Pointer)[i];
 
    XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
    for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
        if (Pointer == XlatTableEntry->Pointer)
        {
            if (XlatTableEntry->State & 0x20)
                return 0;
            XlatTableEntry->State |= 0x20;
            RefId = XlatTableEntry->RefId;
            break;
        }
 
    if (!XlatTableEntry)
        return 0;
 
    if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
    {
        pXlatTables->RefIdToPointer.StateTable[RefId] |= 0x20;
        return 1;
    }
 
    return 0;
}

Referenced by PointerFree(), and test_fullpointer_xlat().

NdrFullPointerInsertRefId()

void WINAPI NdrFullPointerInsertRefId	(	PFULL_PTR_XLAT_TABLES	pXlatTables,
		ULONG	RefId,
		void *	pPointer
	)

Definition at line 188 of file ndr_fullpointer.c.

{
    ULONG Hash = 0;
    unsigned int i;
    PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 
    TRACE("(%p, 0x%x, %p)\n", pXlatTables, RefId, pPointer);
 
    /* simple hashing algorithm, don't know whether it matches native */
    for (i = 0; i < sizeof(pPointer); i++)
        Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 
    XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
    XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
    XlatTableEntry->Pointer = pPointer;
    XlatTableEntry->RefId = RefId;
    XlatTableEntry->State = 0;
    pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 
    /* insert pointer into mapping table */
    expand_pointer_table_if_necessary(pXlatTables, RefId);
    if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
        pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
}

Referenced by PointerUnmarshall(), and test_fullpointer_xlat().

NdrFullPointerQueryPointer()

int WINAPI NdrFullPointerQueryPointer	(	PFULL_PTR_XLAT_TABLES	pXlatTables,
		void *	pPointer,
		unsigned char	QueryType,
		ULONG *	pRefId
	)

Definition at line 109 of file ndr_fullpointer.c.

{
    ULONG Hash = 0;
    unsigned int i;
    PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 
    TRACE("(%p, %p, %d, %p)\n", pXlatTables, pPointer, QueryType, pRefId);
 
    if (!pPointer)
    {
        *pRefId = 0;
        return 1;
    }
 
    /* simple hashing algorithm, don't know whether it matches native */
    for (i = 0; i < sizeof(pPointer); i++)
        Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 
    XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
    for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
        if (pPointer == XlatTableEntry->Pointer)
        {
            *pRefId = XlatTableEntry->RefId;
            if (XlatTableEntry->State & QueryType)
                return 1;
            XlatTableEntry->State |= QueryType;
            return 0;
        }
 
    XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
    XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
    XlatTableEntry->Pointer = pPointer;
    XlatTableEntry->RefId = *pRefId = pXlatTables->NextRefId++;
    XlatTableEntry->State = QueryType;
    pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 
    /* insert pointer into mapping table */
    expand_pointer_table_if_necessary(pXlatTables, XlatTableEntry->RefId);
    if (pXlatTables->RefIdToPointer.NumberOfEntries > XlatTableEntry->RefId)
    {
        pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
        pXlatTables->RefIdToPointer.StateTable[XlatTableEntry->RefId] = QueryType;
    }
 
    return 0;
}

Referenced by PointerBufferSize(), PointerMarshall(), and test_fullpointer_xlat().

NdrFullPointerQueryRefId()

int WINAPI NdrFullPointerQueryRefId	(	PFULL_PTR_XLAT_TABLES	pXlatTables,
		ULONG	RefId,
		unsigned char	QueryType,
		void **	ppPointer
	)

Definition at line 158 of file ndr_fullpointer.c.

{
    TRACE("(%p, 0x%x, %d, %p)\n", pXlatTables, RefId, QueryType, ppPointer);
 
    if (!RefId)
        return 1;
 
    expand_pointer_table_if_necessary(pXlatTables, RefId);
 
    pXlatTables->NextRefId = max(RefId + 1, pXlatTables->NextRefId);
 
    if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
    {
        *ppPointer = pXlatTables->RefIdToPointer.XlatTable[RefId];
        if (QueryType)
        {
            if (pXlatTables->RefIdToPointer.StateTable[RefId] & QueryType)
                return 1;
            pXlatTables->RefIdToPointer.StateTable[RefId] |= QueryType;
            return 0;
        }
        else
            return 0;
    }
    *ppPointer = NULL;
    return 0;
}

Referenced by PointerMemorySize(), PointerUnmarshall(), and test_fullpointer_xlat().

NdrFullPointerXlatFree()

void WINAPI NdrFullPointerXlatFree

(

PFULL_PTR_XLAT_TABLES

pXlatTables

)

Definition at line 64 of file ndr_fullpointer.c.

{
    ULONG i;
 
    TRACE("(%p)\n", pXlatTables);
 
    /* free the entries in the table */
    for (i = 0; i < pXlatTables->PointerToRefId.NumberOfBuckets; i++)
    {
        PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
        for (XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[i];
            XlatTableEntry; )
        {
            PFULL_PTR_TO_REFID_ELEMENT Next = XlatTableEntry->Next;
            HeapFree(GetProcessHeap(), 0, XlatTableEntry);
            XlatTableEntry = Next;
        }
    }
 
    HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.XlatTable);
    HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.StateTable);
    HeapFree(GetProcessHeap(), 0, pXlatTables->PointerToRefId.XlatTable);
 
    HeapFree(GetProcessHeap(), 0, pXlatTables);
}

Referenced by ndr_client_call_finally(), NdrMesProcEncodeDecode(), NdrpCompleteAsyncClientCall(), NdrpCompleteAsyncServerCall(), NdrStubCall2(), and test_fullpointer_xlat().

NdrFullPointerXlatInit()

PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit	(	ULONG	NumberOfPointers,
		XLAT_SIDE	XlatSide
	)

Definition at line 32 of file ndr_fullpointer.c.

{
    ULONG NumberOfBuckets;
    PFULL_PTR_XLAT_TABLES pXlatTables = HeapAlloc(GetProcessHeap(), 0, sizeof(*pXlatTables));
 
    TRACE("(%d, %d)\n", NumberOfPointers, XlatSide);
 
    if (!NumberOfPointers) NumberOfPointers = 512;
    NumberOfBuckets = ((NumberOfPointers + 3) & ~3) - 1;
 
    pXlatTables->RefIdToPointer.XlatTable =
        HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            sizeof(void *) * NumberOfPointers);
    pXlatTables->RefIdToPointer.StateTable =
        HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            sizeof(unsigned char) * NumberOfPointers);
    pXlatTables->RefIdToPointer.NumberOfEntries = NumberOfPointers;
 
    TRACE("NumberOfBuckets = %d\n", NumberOfBuckets);
    pXlatTables->PointerToRefId.XlatTable =
        HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            sizeof(PFULL_PTR_TO_REFID_ELEMENT) * NumberOfBuckets);
    pXlatTables->PointerToRefId.NumberOfBuckets = NumberOfBuckets;
    pXlatTables->PointerToRefId.HashMask = NumberOfBuckets - 1;
 
    pXlatTables->NextRefId = 1;
    pXlatTables->XlatSide = XlatSide;
 
    return pXlatTables;
}

Referenced by do_ndr_async_client_call(), do_ndr_client_call(), NdrAsyncServerCall(), NdrMesProcEncodeDecode(), NdrStubCall2(), and test_fullpointer_xlat().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

rpc

)