dlls/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 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "rpc.h"
  26 #include "rpcndr.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  31
  32 PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers,
  33                                                     XLAT_SIDE XlatSide)
  34 {
  35     ULONG NumberOfBuckets;
  36     PFULL_PTR_XLAT_TABLES pXlatTables = HeapAlloc(GetProcessHeap(), 0, sizeof(*pXlatTables));
  37
  38     TRACE("(%d, %d)\n", NumberOfPointers, XlatSide);
  39
  40     if (!NumberOfPointers) NumberOfPointers = 512;
  41     NumberOfBuckets = ((NumberOfPointers + 3) & ~3) - 1;
  42
  43     pXlatTables->RefIdToPointer.XlatTable =
  44         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  45             sizeof(void *) * NumberOfPointers);
  46     pXlatTables->RefIdToPointer.StateTable =
  47         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  48             sizeof(unsigned char) * NumberOfPointers);
  49     pXlatTables->RefIdToPointer.NumberOfEntries = NumberOfPointers;
  50
  51     TRACE("NumberOfBuckets = %d\n", NumberOfBuckets);
  52     pXlatTables->PointerToRefId.XlatTable =
  53         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  54             sizeof(PFULL_PTR_TO_REFID_ELEMENT) * NumberOfBuckets);
  55     pXlatTables->PointerToRefId.NumberOfBuckets = NumberOfBuckets;
  56     pXlatTables->PointerToRefId.HashMask = NumberOfBuckets - 1;
  57
  58     pXlatTables->NextRefId = 1;
  59     pXlatTables->XlatSide = XlatSide;
  60
  61     return pXlatTables;
  62 }
  63
  64 void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables)
  65 {
  66     ULONG i;
  67
  68     TRACE("(%p)\n", pXlatTables);
  69
  70     /* free the entries in the table */
  71     for (i = 0; i < pXlatTables->PointerToRefId.NumberOfBuckets; i++)
  72     {
  73         PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
  74         for (XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[i];
  75             XlatTableEntry; )
  76         {
  77             PFULL_PTR_TO_REFID_ELEMENT Next = XlatTableEntry->Next;
  78             HeapFree(GetProcessHeap(), 0, XlatTableEntry);
  79             XlatTableEntry = Next;
  80         }
  81     }
  82
  83     HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.XlatTable);
  84     HeapFree(GetProcessHeap(), 0, pXlatTables->RefIdToPointer.StateTable);
  85     HeapFree(GetProcessHeap(), 0, pXlatTables->PointerToRefId.XlatTable);
  86
  87     HeapFree(GetProcessHeap(), 0, pXlatTables);
  88 }
  89
  90 static void expand_pointer_table_if_necessary(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId)
  91 {
  92     if (RefId >= pXlatTables->RefIdToPointer.NumberOfEntries)
  93     {
  94         pXlatTables->RefIdToPointer.NumberOfEntries = RefId * 2;
  95         pXlatTables->RefIdToPointer.XlatTable =
  96             HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  97                 pXlatTables->RefIdToPointer.XlatTable,
  98                 sizeof(void *) * pXlatTables->RefIdToPointer.NumberOfEntries);
  99         pXlatTables->RefIdToPointer.StateTable =
 100             HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 101                 pXlatTables->RefIdToPointer.StateTable,
 102                 sizeof(unsigned char) * pXlatTables->RefIdToPointer.NumberOfEntries);
 103
 104         if (!pXlatTables->RefIdToPointer.XlatTable || !pXlatTables->RefIdToPointer.StateTable)
 105             pXlatTables->RefIdToPointer.NumberOfEntries = 0;
 106     }
 107 }
 108
 109 int WINAPI NdrFullPointerQueryPointer(PFULL_PTR_XLAT_TABLES pXlatTables,
 110                                       void *pPointer, unsigned char QueryType,
 111                                       ULONG *pRefId )
 112 {
 113     ULONG Hash = 0;
 114     int i;
 115     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 116
 117     TRACE("(%p, %p, %d, %p)\n", pXlatTables, pPointer, QueryType, pRefId);
 118
 119     if (!pPointer)
 120     {
 121         *pRefId = 0;
 122         return 1;
 123     }
 124
 125     /* simple hashing algorithm, don't know whether it matches native */
 126     for (i = 0; i < sizeof(pPointer); i++)
 127         Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 128
 129     XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 130     for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
 131         if (pPointer == XlatTableEntry->Pointer)
 132         {
 133             *pRefId = XlatTableEntry->RefId;
 134             if (XlatTableEntry->State & QueryType)
 135                 return 1;
 136             XlatTableEntry->State |= QueryType;
 137             return 0;
 138         }
 139
 140     XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
 141     XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 142     XlatTableEntry->Pointer = pPointer;
 143     XlatTableEntry->RefId = *pRefId = pXlatTables->NextRefId++;
 144     XlatTableEntry->State = QueryType;
 145     pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 146
 147     /* insert pointer into mapping table */
 148     expand_pointer_table_if_necessary(pXlatTables, XlatTableEntry->RefId);
 149     if (pXlatTables->RefIdToPointer.NumberOfEntries > XlatTableEntry->RefId)
 150     {
 151         pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
 152         pXlatTables->RefIdToPointer.StateTable[XlatTableEntry->RefId] = QueryType;
 153     }
 154
 155     return 0;
 156 }
 157
 158 int WINAPI NdrFullPointerQueryRefId(PFULL_PTR_XLAT_TABLES pXlatTables,
 159                                     ULONG RefId, unsigned char QueryType,
 160                                     void **ppPointer)
 161 {
 162     TRACE("(%p, 0x%x, %d, %p)\n", pXlatTables, RefId, QueryType, ppPointer);
 163
 164     expand_pointer_table_if_necessary(pXlatTables, RefId);
 165
 166     pXlatTables->NextRefId = max(RefId + 1, pXlatTables->NextRefId);
 167
 168     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 169     {
 170         *ppPointer = pXlatTables->RefIdToPointer.XlatTable[RefId];
 171         if (QueryType)
 172         {
 173             if (pXlatTables->RefIdToPointer.StateTable[RefId] & QueryType)
 174                 return 1;
 175             pXlatTables->RefIdToPointer.StateTable[RefId] |= QueryType;
 176             return 0;
 177         }
 178         else
 179             return 0;
 180     }
 181     *ppPointer = NULL;
 182     return 0;
 183 }
 184
 185 void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables,
 186                                       ULONG RefId, void *pPointer)
 187 {
 188     ULONG Hash = 0;
 189     int i;
 190     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 191
 192     TRACE("(%p, 0x%x, %p)\n", pXlatTables, RefId, pPointer);
 193
 194     /* simple hashing algorithm, don't know whether it matches native */
 195     for (i = 0; i < sizeof(pPointer); i++)
 196         Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 197
 198     XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
 199     XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 200     XlatTableEntry->Pointer = pPointer;
 201     XlatTableEntry->RefId = RefId;
 202     XlatTableEntry->State = 0;
 203     pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 204
 205     /* insert pointer into mapping table */
 206     expand_pointer_table_if_necessary(pXlatTables, RefId);
 207     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 208         pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
 209 }
 210
 211 int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)
 212 {
 213     ULONG Hash = 0;
 214     int i;
 215     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 216     ULONG RefId = 0;
 217
 218     TRACE("(%p, %p)\n", pXlatTables, Pointer);
 219
 220     if (!Pointer)
 221         return 1;
 222
 223     /* simple hashing algorithm, don't know whether it matches native */
 224     for (i = 0; i < sizeof(Pointer); i++)
 225         Hash = (Hash * 3) ^ ((unsigned char *)&Pointer)[i];
 226
 227     XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 228     for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
 229         if (Pointer == XlatTableEntry->Pointer)
 230         {
 231             if (XlatTableEntry->State & 0x20)
 232                 return 0;
 233             XlatTableEntry->State |= 0x20;
 234             RefId = XlatTableEntry->RefId;
 235             break;
 236         }
 237
 238     if (!XlatTableEntry)
 239         return 0;
 240
 241     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 242     {
 243         pXlatTables->RefIdToPointer.StateTable[RefId] |= 0x20;
 244         return 1;
 245     }
 246
 247     return 0;
 248 }