/* * Full Pointer Translation Routines * * Copyright 2006 Robert Shearman * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <stdarg.h> #include "windef.h" #include "winbase.h" #include "rpc.h" #include "rpcndr.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(rpc); PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers, XLAT_SIDE XlatSide) { 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; } void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables) { 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); } static void expand_pointer_table_if_necessary(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId) { 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; } } int WINAPI NdrFullPointerQueryPointer(PFULL_PTR_XLAT_TABLES pXlatTables, void *pPointer, unsigned char QueryType, ULONG *pRefId ) { 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; } int WINAPI NdrFullPointerQueryRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, unsigned char QueryType, void **ppPointer) { 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; } void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, void *pPointer) { 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; } int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer) { 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; }