git.oblomov.eu Git - wine/blob - 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     unsigned 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     if (!RefId)
 165         return 1;
 166
 167     expand_pointer_table_if_necessary(pXlatTables, RefId);
 168
 169     pXlatTables->NextRefId = max(RefId + 1, pXlatTables->NextRefId);
 170
 171     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 172     {
 173         *ppPointer = pXlatTables->RefIdToPointer.XlatTable[RefId];
 174         if (QueryType)
 175         {
 176             if (pXlatTables->RefIdToPointer.StateTable[RefId] & QueryType)
 177                 return 1;
 178             pXlatTables->RefIdToPointer.StateTable[RefId] |= QueryType;
 179             return 0;
 180         }
 181         else
 182             return 0;
 183     }
 184     *ppPointer = NULL;
 185     return 0;
 186 }
 187
 188 void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables,
 189                                       ULONG RefId, void *pPointer)
 190 {
 191     ULONG Hash = 0;
 192     unsigned int i;
 193     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 194
 195     TRACE("(%p, 0x%x, %p)\n", pXlatTables, RefId, pPointer);
 196
 197     /* simple hashing algorithm, don't know whether it matches native */
 198     for (i = 0; i < sizeof(pPointer); i++)
 199         Hash = (Hash * 3) ^ ((unsigned char *)&pPointer)[i];
 200
 201     XlatTableEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(*XlatTableEntry));
 202     XlatTableEntry->Next = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 203     XlatTableEntry->Pointer = pPointer;
 204     XlatTableEntry->RefId = RefId;
 205     XlatTableEntry->State = 0;
 206     pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask] = XlatTableEntry;
 207
 208     /* insert pointer into mapping table */
 209     expand_pointer_table_if_necessary(pXlatTables, RefId);
 210     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 211         pXlatTables->RefIdToPointer.XlatTable[XlatTableEntry->RefId] = pPointer;
 212 }
 213
 214 int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)
 215 {
 216     ULONG Hash = 0;
 217     unsigned int i;
 218     PFULL_PTR_TO_REFID_ELEMENT XlatTableEntry;
 219     ULONG RefId = 0;
 220
 221     TRACE("(%p, %p)\n", pXlatTables, Pointer);
 222
 223     if (!Pointer)
 224         return 1;
 225
 226     /* simple hashing algorithm, don't know whether it matches native */
 227     for (i = 0; i < sizeof(Pointer); i++)
 228         Hash = (Hash * 3) ^ ((unsigned char *)&Pointer)[i];
 229
 230     XlatTableEntry = pXlatTables->PointerToRefId.XlatTable[Hash & pXlatTables->PointerToRefId.HashMask];
 231     for (; XlatTableEntry; XlatTableEntry = XlatTableEntry->Next)
 232         if (Pointer == XlatTableEntry->Pointer)
 233         {
 234             if (XlatTableEntry->State & 0x20)
 235                 return 0;
 236             XlatTableEntry->State |= 0x20;
 237             RefId = XlatTableEntry->RefId;
 238             break;
 239         }
 240
 241     if (!XlatTableEntry)
 242         return 0;
 243
 244     if (pXlatTables->RefIdToPointer.NumberOfEntries > RefId)
 245     {
 246         pXlatTables->RefIdToPointer.StateTable[RefId] |= 0x20;
 247         return 1;
 248     }
 249
 250     return 0;
 251 }