dll/win32/rpcrt4/ndr_fullpointer.c

   1 /*
   2  * Full Pointer Translation Routines
   3  *
   4  * Copyright 2006 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_NO_STATUS
  22 #define _INC_WINDOWS
  23
  24 #include <stdarg.h>
  25
  26 #include <windef.h>
  27 #include <winbase.h>
  28 #include <rpc.h>
  29 #include <rpcndr.h>
  30
  31 #include <wine/debug.h>
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  34
  35 PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers,
  36                                                     XLAT_SIDE XlatSide)
  37 {
  38     ULONG NumberOfBuckets;
  39     PFULL_PTR_XLAT_TABLES pXlatTables = HeapAlloc(GetProcessHeap(), 0, sizeof(*pXlatTables));
  40
  41     TRACE("(%d, %d)\n", NumberOfPointers, XlatSide);
  42
  43     if (!NumberOfPointers) NumberOfPointers = 512;
  44     NumberOfBuckets = ((NumberOfPointers + 3) & ~3) - 1;
  45
  46     pXlatTables->RefIdToPointer.XlatTable =
  47         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  48             sizeof(void *) * NumberOfPointers);
  49     pXlatTables->RefIdToPointer.StateTable =
  50         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  51             sizeof(unsigned char) * NumberOfPointers);
  52     pXlatTables->RefIdToPointer.NumberOfEntries = NumberOfPointers;
  53
  54     TRACE("NumberOfBuckets = %d\n", NumberOfBuckets);
  55     pXlatTables->PointerToRefId.XlatTable =
  56         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  57             sizeof(PFULL_PTR_TO_REFID_ELEMENT) * NumberOfBuckets);
  58     pXlatTables->PointerToRefId.NumberOfBuckets = NumberOfBuckets;
  59     pXlatTables->PointerToRefId.HashMask = NumberOfBuckets - 1;
  60
  61     pXlatTables->NextRefId = 1;
  62     pXlatTables->XlatSide = XlatSide;
  63
  64     return pXlatTables;
  65 }
  66
  67 void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables)
  68 {
  69     ULONG i;
  70
  71     TRACE("(%p)\n", pXlatTables);
  72
  73     /* free the entries in the table */
  74     for (i = 0; i < pXlatTables->PointerToRefId.NumberOfBuckets; i++)
  75     {
  76         PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
  77         for (XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[i];
  78             XlatTableEntry; )
  79         {
  80             PFULL_PTR_TO_REFID_ELEMENT Next = XlatTableEntry->Next;
  81             HeapFree(GetProcessHeap(), 0, XlatTableEntry);
  82             XlatTableEntry = Next;
  83         }
  84     }
  85
  86     HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.XlatTable);
  87     HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.StateTable);
  88     HeapFree(GetProcessHeap(), 0, pXlatTables->PointerToRefId.XlatTable);
  89
  90     HeapFree(GetProcessHeap(), 0, pXlatTables);
  91 }
  92
  93 static void expand_pointer_table_if_necessary(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId)
  94 {
  95     if (RefId >= pXlatTables->RefIdToPointer.NumberOfEntries)
  96     {
  97         pXlatTables->RefIdToPointer.NumberOfEntries = RefId * 2;
  98         pXlatTables->RefIdToPointer.XlatTable =
  99             HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 100                 pXlatTables->RefIdToPointer.XlatTable,
 101                 sizeof(void *) * pXlatTables->RefIdToPointer.NumberOfEntries);
 102         pXlatTables->RefIdToPointer.StateTable =
 103             HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 104                 pXlatTables->RefIdToPointer.StateTable,
 105                 sizeof(unsigned char) * pXlatTables->RefIdToPointer.NumberOfEntries);
 106
 107         if (!pXlatTables->RefIdToPointer.XlatTable || !pXlatTables->RefIdToPointer.StateTable)
 108             pXlatTables->RefIdToPointer.NumberOfEntries = 0;
 109     }
 110 }
 111
 112 int WINAPI NdrFullPointerQueryPointer(PFULL_PTR_XLAT_TABLES pXlatTables,
 113                                       void *pPointer, unsigned char QueryType,
 114                                       ULONG *pRefId )
 115 {
 116     ULONG Hash = 0;
 117     unsigned int i;
 118     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 119
 120     TRACE("(%p, %p, %d, %p)\n", pXlatTables, pPointer, QueryType, pRefId);
 121
 122     if (!pPointer)
 123     {
 124         *pRefId = 0;
 125         return 1;
 126     }
 127
 128     /* simple hashing algorithm, don't know whether it matches native */
 129     for (i = 0; i < sizeof(pPointer); i++)
 130         Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 131
 132     XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 133     for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
 134         if (pPointer == XlatTableEntry->Pointer)
 135         {
 136             *pRefId = XlatTableEntry->RefId;
 137             if (XlatTableEntry->State & QueryType)
 138                 return 1;
 139             XlatTableEntry->State |= QueryType;
 140             return 0;
 141         }
 142
 143     XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
 144     XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 145     XlatTableEntry->Pointer = pPointer;
 146     XlatTableEntry->RefId = *pRefId = pXlatTables->NextRefId++;
 147     XlatTableEntry->State = QueryType;
 148     pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 149
 150     /* insert pointer into mapping table */
 151     expand_pointer_table_if_necessary(pXlatTables, XlatTableEntry->RefId);
 152     if (pXlatTables->RefIdToPointer.NumberOfEntries > XlatTableEntry->RefId)
 153     {
 154         pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
 155         pXlatTables->RefIdToPointer.StateTable[XlatTableEntry->RefId] = QueryType;
 156     }
 157
 158     return 0;
 159 }
 160
 161 int WINAPI NdrFullPointerQueryRefId(PFULL_PTR_XLAT_TABLES pXlatTables,
 162                                     ULONG RefId, unsigned char QueryType,
 163                                     void **ppPointer)
 164 {
 165     TRACE("(%p, 0x%x, %d, %p)\n", pXlatTables, RefId, QueryType, ppPointer);
 166
 167     if (!RefId)
 168         return 1;
 169
 170     expand_pointer_table_if_necessary(pXlatTables, RefId);
 171
 172     pXlatTables->NextRefId = max(RefId + 1, pXlatTables->NextRefId);
 173
 174     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 175     {
 176         *ppPointer = pXlatTables->RefIdToPointer.XlatTable[RefId];
 177         if (QueryType)
 178         {
 179             if (pXlatTables->RefIdToPointer.StateTable[RefId] & QueryType)
 180                 return 1;
 181             pXlatTables->RefIdToPointer.StateTable[RefId] |= QueryType;
 182             return 0;
 183         }
 184         else
 185             return 0;
 186     }
 187     *ppPointer = NULL;
 188     return 0;
 189 }
 190
 191 void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables,
 192                                       ULONG RefId, void *pPointer)
 193 {
 194     ULONG Hash = 0;
 195     unsigned int i;
 196     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 197
 198     TRACE("(%p, 0x%x, %p)\n", pXlatTables, RefId, pPointer);
 199
 200     /* simple hashing algorithm, don't know whether it matches native */
 201     for (i = 0; i < sizeof(pPointer); i++)
 202         Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 203
 204     XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
 205     XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 206     XlatTableEntry->Pointer = pPointer;
 207     XlatTableEntry->RefId = RefId;
 208     XlatTableEntry->State = 0;
 209     pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 210
 211     /* insert pointer into mapping table */
 212     expand_pointer_table_if_necessary(pXlatTables, RefId);
 213     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 214         pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
 215 }
 216
 217 int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)
 218 {
 219     ULONG Hash = 0;
 220     unsigned int i;
 221     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 222     ULONG RefId = 0;
 223
 224     TRACE("(%p, %p)\n", pXlatTables, Pointer);
 225
 226     if (!Pointer)
 227         return 1;
 228
 229     /* simple hashing algorithm, don't know whether it matches native */
 230     for (i = 0; i < sizeof(Pointer); i++)
 231         Hash = (Hash * 3) ^ ((unsigned char *)&Pointer)[i];
 232
 233     XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 234     for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
 235         if (Pointer == XlatTableEntry->Pointer)
 236         {
 237             if (XlatTableEntry->State & 0x20)
 238                 return 0;
 239             XlatTableEntry->State |= 0x20;
 240             RefId = XlatTableEntry->RefId;
 241             break;
 242         }
 243
 244     if (!XlatTableEntry)
 245         return 0;
 246
 247     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 248     {
 249         pXlatTables->RefIdToPointer.StateTable[RefId] |= 0x20;
 250         return 1;
 251     }
 252
 253     return 0;
 254 }