[INETCOMM] Sync with Wine Staging 1.9.4. CORE-10912 [PSDK] Update objidl.idl. [MAPI32...
[reactos.git] / reactos / dll / win32 / ole32 / ifs.c
1 /*
2 * basic interfaces
3 *
4 * Copyright 1997 Marcus Meissner
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 "precomp.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(olemalloc);
24
25 /******************************************************************************
26 * IMalloc32 implementation
27 *
28 * NOTES
29 * For supporting CoRegisterMallocSpy the IMalloc implementation must know if
30 * a given memory block was allocated with a spy active.
31 *
32 *****************************************************************************/
33 /* set the vtable later */
34 static const IMallocVtbl VT_IMalloc32;
35
36 typedef struct {
37 IMalloc IMalloc_iface;
38 DWORD dummy; /* nothing, we are static */
39 IMallocSpy * pSpy; /* the spy when active */
40 DWORD SpyedAllocationsLeft; /* number of spyed allocations left */
41 BOOL SpyReleasePending; /* CoRevokeMallocSpy called with spyed allocations left*/
42 LPVOID * SpyedBlocks; /* root of the table */
43 DWORD SpyedBlockTableLength;/* size of the table*/
44 } _Malloc32;
45
46 /* this is the static object instance */
47 static _Malloc32 Malloc32 = {{&VT_IMalloc32}, 0, NULL, 0, 0, NULL, 0};
48
49 /* with a spy active all calls from pre to post methods are threadsave */
50 static CRITICAL_SECTION IMalloc32_SpyCS;
51 static CRITICAL_SECTION_DEBUG critsect_debug =
52 {
53 0, 0, &IMalloc32_SpyCS,
54 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
55 0, 0, { (DWORD_PTR)(__FILE__ ": IMalloc32_SpyCS") }
56 };
57 static CRITICAL_SECTION IMalloc32_SpyCS = { &critsect_debug, -1, 0, 0, 0, 0 };
58
59 /* resize the old table */
60 static BOOL SetSpyedBlockTableLength ( DWORD NewLength )
61 {
62 LPVOID *NewSpyedBlocks;
63
64 if (!Malloc32.SpyedBlocks) NewSpyedBlocks = LocalAlloc(LMEM_ZEROINIT, NewLength * sizeof(PVOID));
65 else NewSpyedBlocks = LocalReAlloc(Malloc32.SpyedBlocks, NewLength * sizeof(PVOID), LMEM_ZEROINIT | LMEM_MOVEABLE);
66 if (NewSpyedBlocks) {
67 Malloc32.SpyedBlocks = NewSpyedBlocks;
68 Malloc32.SpyedBlockTableLength = NewLength;
69 }
70
71 return NewSpyedBlocks != NULL;
72 }
73
74 /* add a location to the table */
75 static BOOL AddMemoryLocation(LPVOID * pMem)
76 {
77 LPVOID * Current;
78
79 /* allocate the table if not already allocated */
80 if (!Malloc32.SpyedBlockTableLength && !SetSpyedBlockTableLength(0x1000))
81 return FALSE;
82
83 /* find a free location */
84 Current = Malloc32.SpyedBlocks;
85 while (*Current) {
86 Current++;
87 if (Current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength) {
88 /* no more space in table, grow it */
89 DWORD old_length = Malloc32.SpyedBlockTableLength;
90 if (!SetSpyedBlockTableLength( Malloc32.SpyedBlockTableLength + 0x1000))
91 return FALSE;
92 Current = Malloc32.SpyedBlocks + old_length;
93 }
94 };
95
96 /* put the location in our table */
97 *Current = pMem;
98 Malloc32.SpyedAllocationsLeft++;
99 /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
100 return TRUE;
101 }
102
103 static BOOL RemoveMemoryLocation(LPCVOID pMem)
104 {
105 LPVOID * Current;
106
107 /* allocate the table if not already allocated */
108 if (!Malloc32.SpyedBlockTableLength && !SetSpyedBlockTableLength(0x1000))
109 return FALSE;
110
111 Current = Malloc32.SpyedBlocks;
112
113 /* find the location */
114 while (*Current != pMem) {
115 Current++;
116 if (Current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength)
117 return FALSE; /* not found */
118 }
119
120 /* location found */
121 Malloc32.SpyedAllocationsLeft--;
122 /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
123 *Current = NULL;
124 return TRUE;
125 }
126
127 /******************************************************************************
128 * IMalloc32_QueryInterface [VTABLE]
129 */
130 static HRESULT WINAPI IMalloc_fnQueryInterface(LPMALLOC iface,REFIID refiid,LPVOID *obj) {
131
132 TRACE("(%s,%p)\n",debugstr_guid(refiid),obj);
133
134 if (IsEqualIID(&IID_IUnknown,refiid) || IsEqualIID(&IID_IMalloc,refiid)) {
135 *obj = &Malloc32;
136 return S_OK;
137 }
138 return E_NOINTERFACE;
139 }
140
141 /******************************************************************************
142 * IMalloc32_AddRefRelease [VTABLE]
143 */
144 static ULONG WINAPI IMalloc_fnAddRefRelease (LPMALLOC iface) {
145 return 1;
146 }
147
148 /******************************************************************************
149 * IMalloc32_Alloc [VTABLE]
150 */
151 static LPVOID WINAPI IMalloc_fnAlloc(LPMALLOC iface, SIZE_T cb) {
152
153 LPVOID addr;
154
155 TRACE("(%d)\n",cb);
156
157 if(Malloc32.pSpy) {
158 DWORD preAllocResult;
159
160 EnterCriticalSection(&IMalloc32_SpyCS);
161 preAllocResult = IMallocSpy_PreAlloc(Malloc32.pSpy, cb);
162 if ((cb != 0) && (preAllocResult == 0)) {
163 /* PreAlloc can force Alloc to fail, but not if cb == 0 */
164 TRACE("returning null\n");
165 LeaveCriticalSection(&IMalloc32_SpyCS);
166 return NULL;
167 }
168 }
169
170 addr = HeapAlloc(GetProcessHeap(),0,cb);
171
172 if(Malloc32.pSpy) {
173 addr = IMallocSpy_PostAlloc(Malloc32.pSpy, addr);
174 if (addr) AddMemoryLocation(addr);
175 LeaveCriticalSection(&IMalloc32_SpyCS);
176 }
177
178 TRACE("--(%p)\n",addr);
179 return addr;
180 }
181
182 /******************************************************************************
183 * IMalloc32_Realloc [VTABLE]
184 */
185 static LPVOID WINAPI IMalloc_fnRealloc(LPMALLOC iface,LPVOID pv,SIZE_T cb) {
186
187 LPVOID pNewMemory;
188
189 TRACE("(%p,%d)\n",pv,cb);
190
191 if(Malloc32.pSpy) {
192 LPVOID pRealMemory;
193 BOOL fSpyed;
194
195 EnterCriticalSection(&IMalloc32_SpyCS);
196 fSpyed = RemoveMemoryLocation(pv);
197 cb = IMallocSpy_PreRealloc(Malloc32.pSpy, pv, cb, &pRealMemory, fSpyed);
198
199 /* check if can release the spy */
200 if(Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) {
201 IMallocSpy_Release(Malloc32.pSpy);
202 Malloc32.SpyReleasePending = FALSE;
203 Malloc32.pSpy = NULL;
204 LeaveCriticalSection(&IMalloc32_SpyCS);
205 }
206
207 if (0==cb) {
208 /* PreRealloc can force Realloc to fail */
209 if (Malloc32.pSpy)
210 LeaveCriticalSection(&IMalloc32_SpyCS);
211 return NULL;
212 }
213
214 pv = pRealMemory;
215 }
216
217 if (!pv) pNewMemory = HeapAlloc(GetProcessHeap(),0,cb);
218 else if (cb) pNewMemory = HeapReAlloc(GetProcessHeap(),0,pv,cb);
219 else {
220 HeapFree(GetProcessHeap(),0,pv);
221 pNewMemory = NULL;
222 }
223
224 if(Malloc32.pSpy) {
225 pNewMemory = IMallocSpy_PostRealloc(Malloc32.pSpy, pNewMemory, TRUE);
226 if (pNewMemory) AddMemoryLocation(pNewMemory);
227 LeaveCriticalSection(&IMalloc32_SpyCS);
228 }
229
230 TRACE("--(%p)\n",pNewMemory);
231 return pNewMemory;
232 }
233
234 /******************************************************************************
235 * IMalloc32_Free [VTABLE]
236 */
237 static VOID WINAPI IMalloc_fnFree(LPMALLOC iface,LPVOID pv) {
238
239 BOOL fSpyed = FALSE;
240
241 TRACE("(%p)\n",pv);
242
243 if(Malloc32.pSpy) {
244 EnterCriticalSection(&IMalloc32_SpyCS);
245 fSpyed = RemoveMemoryLocation(pv);
246 pv = IMallocSpy_PreFree(Malloc32.pSpy, pv, fSpyed);
247 }
248
249 HeapFree(GetProcessHeap(),0,pv);
250
251 if(Malloc32.pSpy) {
252 IMallocSpy_PostFree(Malloc32.pSpy, fSpyed);
253
254 /* check if can release the spy */
255 if(Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) {
256 IMallocSpy_Release(Malloc32.pSpy);
257 Malloc32.SpyReleasePending = FALSE;
258 Malloc32.pSpy = NULL;
259 }
260
261 LeaveCriticalSection(&IMalloc32_SpyCS);
262 }
263 }
264
265 /******************************************************************************
266 * IMalloc32_GetSize [VTABLE]
267 *
268 * NOTES
269 * FIXME returns:
270 * win95: size allocated (4 byte boundarys)
271 * win2k: size originally requested !!! (allocated on 8 byte boundarys)
272 */
273 static SIZE_T WINAPI IMalloc_fnGetSize(LPMALLOC iface,LPVOID pv) {
274
275 DWORD cb;
276 BOOL fSpyed = FALSE;
277
278 TRACE("(%p)\n",pv);
279
280 if(Malloc32.pSpy) {
281 EnterCriticalSection(&IMalloc32_SpyCS);
282 pv = IMallocSpy_PreGetSize(Malloc32.pSpy, pv, fSpyed);
283 }
284
285 cb = HeapSize(GetProcessHeap(),0,pv);
286
287 if(Malloc32.pSpy) {
288 cb = IMallocSpy_PostGetSize(Malloc32.pSpy, cb, fSpyed);
289 LeaveCriticalSection(&IMalloc32_SpyCS);
290 }
291
292 return cb;
293 }
294
295 /******************************************************************************
296 * IMalloc32_DidAlloc [VTABLE]
297 */
298 static INT WINAPI IMalloc_fnDidAlloc(LPMALLOC iface,LPVOID pv) {
299
300 BOOL fSpyed = FALSE;
301 int didAlloc;
302
303 TRACE("(%p)\n",pv);
304
305 if(Malloc32.pSpy) {
306 EnterCriticalSection(&IMalloc32_SpyCS);
307 pv = IMallocSpy_PreDidAlloc(Malloc32.pSpy, pv, fSpyed);
308 }
309
310 didAlloc = -1;
311
312 if(Malloc32.pSpy) {
313 didAlloc = IMallocSpy_PostDidAlloc(Malloc32.pSpy, pv, fSpyed, didAlloc);
314 LeaveCriticalSection(&IMalloc32_SpyCS);
315 }
316 return didAlloc;
317 }
318
319 /******************************************************************************
320 * IMalloc32_HeapMinimize [VTABLE]
321 */
322 static VOID WINAPI IMalloc_fnHeapMinimize(LPMALLOC iface) {
323 TRACE("()\n");
324
325 if(Malloc32.pSpy) {
326 EnterCriticalSection(&IMalloc32_SpyCS);
327 IMallocSpy_PreHeapMinimize(Malloc32.pSpy);
328 }
329
330 if(Malloc32.pSpy) {
331 IMallocSpy_PostHeapMinimize(Malloc32.pSpy);
332 LeaveCriticalSection(&IMalloc32_SpyCS);
333 }
334 }
335
336 static const IMallocVtbl VT_IMalloc32 =
337 {
338 IMalloc_fnQueryInterface,
339 IMalloc_fnAddRefRelease,
340 IMalloc_fnAddRefRelease,
341 IMalloc_fnAlloc,
342 IMalloc_fnRealloc,
343 IMalloc_fnFree,
344 IMalloc_fnGetSize,
345 IMalloc_fnDidAlloc,
346 IMalloc_fnHeapMinimize
347 };
348
349 /******************************************************************************
350 * CoGetMalloc [OLE32.@]
351 *
352 * Retrieves the current IMalloc interface for the process.
353 *
354 * PARAMS
355 * dwMemContext [I]
356 * lpMalloc [O] Address where memory allocator object will be stored.
357 *
358 * RETURNS
359 * Success: S_OK.
360 * Failure: HRESULT code.
361 */
362 HRESULT WINAPI CoGetMalloc(DWORD dwMemContext, LPMALLOC *lpMalloc)
363 {
364 *lpMalloc = &Malloc32.IMalloc_iface;
365 return S_OK;
366 }
367
368 /***********************************************************************
369 * CoTaskMemAlloc [OLE32.@]
370 *
371 * Allocates memory using the current process memory allocator.
372 *
373 * PARAMS
374 * size [I] Size of the memory block to allocate.
375 *
376 * RETURNS
377 * Success: Pointer to newly allocated memory block.
378 * Failure: NULL.
379 */
380 LPVOID WINAPI CoTaskMemAlloc(ULONG size)
381 {
382 return IMalloc_Alloc(&Malloc32.IMalloc_iface,size);
383 }
384
385 /***********************************************************************
386 * CoTaskMemFree [OLE32.@]
387 *
388 * Frees memory allocated from the current process memory allocator.
389 *
390 * PARAMS
391 * ptr [I] Memory block to free.
392 *
393 * RETURNS
394 * Nothing.
395 */
396 VOID WINAPI CoTaskMemFree(LPVOID ptr)
397 {
398 IMalloc_Free(&Malloc32.IMalloc_iface, ptr);
399 }
400
401 /***********************************************************************
402 * CoTaskMemRealloc [OLE32.@]
403 *
404 * Allocates memory using the current process memory allocator.
405 *
406 * PARAMS
407 * pvOld [I] Pointer to old memory block.
408 * size [I] Size of the new memory block.
409 *
410 * RETURNS
411 * Success: Pointer to newly allocated memory block.
412 * Failure: NULL.
413 */
414 LPVOID WINAPI CoTaskMemRealloc(LPVOID pvOld, ULONG size)
415 {
416 return IMalloc_Realloc(&Malloc32.IMalloc_iface, pvOld, size);
417 }
418
419 /***********************************************************************
420 * CoRegisterMallocSpy [OLE32.@]
421 *
422 * Registers an object that receives notifications on memory allocations and
423 * frees.
424 *
425 * PARAMS
426 * pMallocSpy [I] New spy object.
427 *
428 * RETURNS
429 * Success: S_OK.
430 * Failure: HRESULT code.
431 *
432 * NOTES
433 * if a mallocspy is already registered, we can't do it again since
434 * only the spy knows, how to free a memory block
435 */
436 HRESULT WINAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy)
437 {
438 IMallocSpy* pSpy;
439 HRESULT hres = E_INVALIDARG;
440
441 TRACE("\n");
442
443 if(Malloc32.pSpy) return CO_E_OBJISREG;
444
445 EnterCriticalSection(&IMalloc32_SpyCS);
446
447 if (SUCCEEDED(IMallocSpy_QueryInterface(pMallocSpy, &IID_IMallocSpy, (void**)&pSpy))) {
448 Malloc32.pSpy = pSpy;
449 hres = S_OK;
450 }
451
452 LeaveCriticalSection(&IMalloc32_SpyCS);
453
454 return hres;
455 }
456
457 /***********************************************************************
458 * CoRevokeMallocSpy [OLE32.@]
459 *
460 * Revokes a previously registered object that receives notifications on memory
461 * allocations and frees.
462 *
463 * PARAMS
464 * pMallocSpy [I] New spy object.
465 *
466 * RETURNS
467 * Success: S_OK.
468 * Failure: HRESULT code.
469 *
470 * NOTES
471 * we can't revoke a malloc spy as long as memory blocks allocated with
472 * the spy are active since only the spy knows how to free them
473 */
474 HRESULT WINAPI CoRevokeMallocSpy(void)
475 {
476 HRESULT hres = S_OK;
477 TRACE("\n");
478
479 EnterCriticalSection(&IMalloc32_SpyCS);
480
481 if (Malloc32.SpyedAllocationsLeft) {
482 TRACE("SpyReleasePending with %u allocations left\n", Malloc32.SpyedAllocationsLeft);
483 Malloc32.SpyReleasePending = TRUE;
484 hres = E_ACCESSDENIED;
485 } else {
486 IMallocSpy_Release(Malloc32.pSpy);
487 Malloc32.pSpy = NULL;
488 }
489 LeaveCriticalSection(&IMalloc32_SpyCS);
490
491 return hres;
492 }
493
494 /******************************************************************************
495 * IsValidInterface [OLE32.@]
496 *
497 * Determines whether a pointer is a valid interface.
498 *
499 * PARAMS
500 * punk [I] Interface to be tested.
501 *
502 * RETURNS
503 * TRUE, if the passed pointer is a valid interface, or FALSE otherwise.
504 */
505 BOOL WINAPI IsValidInterface(LPUNKNOWN punk)
506 {
507 return !(
508 IsBadReadPtr(punk,4) ||
509 IsBadReadPtr(punk->lpVtbl,4) ||
510 IsBadReadPtr(punk->lpVtbl->QueryInterface,9) ||
511 IsBadCodePtr((FARPROC)punk->lpVtbl->QueryInterface)
512 );
513 }