ReactOS  0.4.14-dev-98-gb0d4763
ndr_fullpointer.c
Go to the documentation of this file.
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 
31 
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 =
45  sizeof(void *) * NumberOfPointers);
46  pXlatTables->RefIdToPointer.StateTable =
48  sizeof(unsigned char) * NumberOfPointers);
49  pXlatTables->RefIdToPointer.NumberOfEntries = NumberOfPointers;
50 
51  TRACE("NumberOfBuckets = %d\n", NumberOfBuckets);
52  pXlatTables->PointerToRefId.XlatTable =
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 
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 
91 {
92  if (RefId >= pXlatTables->RefIdToPointer.NumberOfEntries)
93  {
94  pXlatTables->RefIdToPointer.NumberOfEntries = RefId * 2;
95  pXlatTables->RefIdToPointer.XlatTable =
97  pXlatTables->RefIdToPointer.XlatTable,
98  sizeof(void *) * pXlatTables->RefIdToPointer.NumberOfEntries);
99  pXlatTables->RefIdToPointer.StateTable =
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 
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 
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 
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 }
static int Hash(const char *)
Definition: reader.c:2257
#define max(a, b)
Definition: svc.c:63
int WINAPI NdrFullPointerQueryRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, unsigned char QueryType, void **ppPointer)
void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables)
unsigned char State
Definition: rpcndr.h:471
struct _FULL_PTR_TO_REFID_ELEMENT * Next
Definition: rpcndr.h:468
int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
WINE_DEFAULT_DEBUG_CHANNEL(rpc)
smooth NULL
Definition: ftsmooth.c:416
XLAT_SIDE
Definition: rpcndr.h:462
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
XLAT_SIDE XlatSide
Definition: rpcndr.h:489
#define WINAPI
Definition: msvc.h:8
_Must_inspect_result_ _In_ KTMOBJECT_TYPE QueryType
Definition: nttmapi.h:404
struct _FULL_PTR_XLAT_TABLES::@3091 RefIdToPointer
PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers, XLAT_SIDE XlatSide)
#define HeapReAlloc
Definition: compat.h:393
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, void *pPointer)
unsigned int ULONG
Definition: retypes.h:1
static void expand_pointer_table_if_necessary(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId)
#define HeapFree(x, y, z)
Definition: compat.h:394
int WINAPI NdrFullPointerQueryPointer(PFULL_PTR_XLAT_TABLES pXlatTables, void *pPointer, unsigned char QueryType, ULONG *pRefId)
struct _FULL_PTR_XLAT_TABLES::@3092 PointerToRefId