[WIN32K]
[reactos.git] / reactos / win32ss / user / ntuser / object.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: User handle manager
5 * FILE: subsystems/win32/win32k/ntuser/object.c
6 * PROGRAMER: Copyright (C) 2001 Alexandre Julliard
7 */
8
9 #include <win32k.h>
10 DBG_DEFAULT_CHANNEL(UserObj);
11
12 //int usedHandles=0;
13 PUSER_HANDLE_TABLE gHandleTable = NULL;
14
15 /* Forward declarations */
16 static PVOID AllocThreadObject(
17 _In_ PDESKTOP pDesk,
18 _In_ PTHREADINFO pti,
19 _In_ SIZE_T Size,
20 _Out_ PVOID* HandleOwner)
21 {
22 PTHROBJHEAD ObjHead;
23
24 UNREFERENCED_PARAMETER(pDesk);
25
26 ASSERT(Size > sizeof(*ObjHead));
27 ASSERT(pti != NULL);
28
29 ObjHead = UserHeapAlloc(Size);
30 if (!ObjHead)
31 return NULL;
32
33 RtlZeroMemory(ObjHead, Size);
34
35 ObjHead->pti = pti;
36 IntReferenceThreadInfo(pti);
37 *HandleOwner = pti;
38 /* It's a thread object, but it still count as one for the process */
39 pti->ppi->UserHandleCount++;
40
41 return ObjHead;
42 }
43
44 static void FreeThreadObject(
45 _In_ PVOID Object)
46 {
47 PTHROBJHEAD ObjHead = (PTHROBJHEAD)Object;
48 PTHREADINFO pti = ObjHead->pti;
49
50 UserHeapFree(ObjHead);
51
52 pti->ppi->UserHandleCount--;
53 IntDereferenceThreadInfo(pti);
54 }
55
56 static PVOID AllocDeskThreadObject(
57 _In_ PDESKTOP pDesk,
58 _In_ PTHREADINFO pti,
59 _In_ SIZE_T Size,
60 _Out_ PVOID* HandleOwner)
61 {
62 PTHRDESKHEAD ObjHead;
63
64 ASSERT(Size > sizeof(*ObjHead));
65 ASSERT(pti != NULL);
66
67 if (!pDesk)
68 pDesk = pti->rpdesk;
69
70 ObjHead = DesktopHeapAlloc(pDesk, Size);
71 if (!ObjHead)
72 return NULL;
73
74 RtlZeroMemory(ObjHead, Size);
75
76 ObjHead->pSelf = ObjHead;
77 ObjHead->rpdesk = pDesk;
78 ObjHead->pti = pti;
79 IntReferenceThreadInfo(pti);
80 *HandleOwner = pti;
81 /* It's a thread object, but it still count as one for the process */
82 pti->ppi->UserHandleCount++;
83
84 return ObjHead;
85 }
86
87 static void FreeDeskThreadObject(
88 _In_ PVOID Object)
89 {
90 PTHRDESKHEAD ObjHead = (PTHRDESKHEAD)Object;
91 PDESKTOP pDesk = ObjHead->rpdesk;
92 PTHREADINFO pti = ObjHead->pti;
93
94 DesktopHeapFree(pDesk, Object);
95
96 pti->ppi->UserHandleCount--;
97 IntDereferenceThreadInfo(pti);
98 }
99
100 static PVOID AllocDeskProcObject(
101 _In_ PDESKTOP pDesk,
102 _In_ PTHREADINFO pti,
103 _In_ SIZE_T Size,
104 _Out_ PVOID* HandleOwner)
105 {
106 PPROCDESKHEAD ObjHead;
107 PPROCESSINFO ppi;
108
109 ASSERT(Size > sizeof(*ObjHead));
110 ASSERT(pDesk != NULL);
111 ASSERT(pti != NULL);
112
113 ObjHead = DesktopHeapAlloc(pDesk, Size);
114 if (!ObjHead)
115 return NULL;
116
117 RtlZeroMemory(ObjHead, Size);
118
119 ppi = pti->ppi;
120
121 ObjHead->pSelf = ObjHead;
122 ObjHead->rpdesk = pDesk;
123 ObjHead->hTaskWow = (DWORD_PTR)ppi;
124 ppi->UserHandleCount++;
125 IntReferenceProcessInfo(ppi);
126 *HandleOwner = ppi;
127
128 return ObjHead;
129 }
130
131 static void FreeDeskProcObject(
132 _In_ PVOID Object)
133 {
134 PPROCDESKHEAD ObjHead = (PPROCDESKHEAD)Object;
135 PDESKTOP pDesk = ObjHead->rpdesk;
136 PPROCESSINFO ppi = (PPROCESSINFO)ObjHead->hTaskWow;
137
138 ppi->UserHandleCount--;
139 IntDereferenceProcessInfo(ppi);
140
141 DesktopHeapFree(pDesk, Object);
142 }
143
144 static PVOID AllocProcMarkObject(
145 _In_ PDESKTOP pDesk,
146 _In_ PTHREADINFO pti,
147 _In_ SIZE_T Size,
148 _Out_ PVOID* HandleOwner)
149 {
150 PPROCMARKHEAD ObjHead;
151 PPROCESSINFO ppi = pti->ppi;
152
153 UNREFERENCED_PARAMETER(pDesk);
154
155 ASSERT(Size > sizeof(*ObjHead));
156
157 ObjHead = UserHeapAlloc(Size);
158 if (!ObjHead)
159 return NULL;
160
161 RtlZeroMemory(ObjHead, Size);
162
163 ObjHead->ppi = ppi;
164 IntReferenceProcessInfo(ppi);
165 *HandleOwner = ppi;
166 ppi->UserHandleCount++;
167
168 return ObjHead;
169 }
170
171 static void FreeProcMarkObject(
172 _In_ PVOID Object)
173 {
174 PPROCESSINFO ppi = ((PPROCMARKHEAD)Object)->ppi;
175
176 UserHeapFree(Object);
177
178 ppi->UserHandleCount--;
179 IntDereferenceProcessInfo(ppi);
180 }
181
182 static PVOID AllocSysObject(
183 _In_ PDESKTOP pDesk,
184 _In_ PTHREADINFO pti,
185 _In_ SIZE_T Size,
186 _Out_ PVOID* ObjectOwner)
187 {
188 PVOID Object;
189
190 UNREFERENCED_PARAMETER(pDesk);
191 UNREFERENCED_PARAMETER(pti);
192
193 ASSERT(Size > sizeof(HEAD));
194
195 Object = UserHeapAlloc(Size);
196 if (!Object)
197 return NULL;
198
199 *ObjectOwner = NULL;
200
201 RtlZeroMemory(Object, Size);
202 return Object;
203 }
204
205 static void FreeSysObject(
206 _In_ PVOID Object)
207 {
208 UserHeapFree(Object);
209 }
210
211 static const struct
212 {
213 PVOID (*ObjectAlloc)(PDESKTOP, PTHREADINFO, SIZE_T, PVOID*);
214 BOOLEAN (*ObjectDestroy)(PVOID);
215 void (*ObjectFree)(PVOID);
216 } ObjectCallbacks[TYPE_CTYPES] =
217 {
218 { NULL, NULL, NULL }, /* TYPE_FREE */
219 { AllocDeskThreadObject, co_UserDestroyWindow, FreeDeskThreadObject }, /* TYPE_WINDOW */
220 { AllocDeskProcObject, UserDestroyMenuObject, FreeDeskProcObject }, /* TYPE_MENU */
221 { AllocProcMarkObject, /*UserCursorCleanup*/NULL, FreeProcMarkObject }, /* TYPE_CURSOR */
222 { AllocSysObject, /*UserSetWindowPosCleanup*/NULL, FreeSysObject }, /* TYPE_SETWINDOWPOS */
223 { AllocDeskThreadObject, IntRemoveHook, FreeDeskThreadObject }, /* TYPE_HOOK */
224 { AllocSysObject, /*UserClipDataCleanup*/NULL,FreeSysObject }, /* TYPE_CLIPDATA */
225 { AllocDeskProcObject, DestroyCallProc, FreeDeskProcObject }, /* TYPE_CALLPROC */
226 { AllocProcMarkObject, UserDestroyAccelTable, FreeProcMarkObject }, /* TYPE_ACCELTABLE */
227 { NULL, NULL, NULL }, /* TYPE_DDEACCESS */
228 { NULL, NULL, NULL }, /* TYPE_DDECONV */
229 { NULL, NULL, NULL }, /* TYPE_DDEXACT */
230 { AllocSysObject, /*UserMonitorCleanup*/NULL, FreeSysObject }, /* TYPE_MONITOR */
231 { AllocSysObject, /*UserKbdLayoutCleanup*/NULL,FreeSysObject }, /* TYPE_KBDLAYOUT */
232 { AllocSysObject, /*UserKbdFileCleanup*/NULL, FreeSysObject }, /* TYPE_KBDFILE */
233 { AllocThreadObject, IntRemoveEvent, FreeThreadObject }, /* TYPE_WINEVENTHOOK */
234 { AllocSysObject, /*UserTimerCleanup*/NULL, FreeSysObject }, /* TYPE_TIMER */
235 { NULL, NULL, NULL }, /* TYPE_INPUTCONTEXT */
236 { NULL, NULL, NULL }, /* TYPE_HIDDATA */
237 { NULL, NULL, NULL }, /* TYPE_DEVICEINFO */
238 { NULL, NULL, NULL }, /* TYPE_TOUCHINPUTINFO */
239 { NULL, NULL, NULL }, /* TYPE_GESTUREINFOOBJ */
240 };
241
242 #if DBG
243
244 void DbgUserDumpHandleTable()
245 {
246 int HandleCounts[TYPE_CTYPES];
247 PPROCESSINFO ppiList;
248 int i;
249 PWCHAR TypeNames[] = {L"Free",L"Window",L"Menu", L"CursorIcon", L"SMWP", L"Hook", L"ClipBoardData", L"CallProc",
250 L"Accel", L"DDEaccess", L"DDEconv", L"DDExact", L"Monitor", L"KBDlayout", L"KBDfile",
251 L"Event", L"Timer", L"InputContext", L"HidData", L"DeviceInfo", L"TouchInput",L"GestureInfo"};
252
253 ERR("Total handles count: %lu\n", gpsi->cHandleEntries);
254
255 memset(HandleCounts, 0, sizeof(HandleCounts));
256
257 /* First of all count the number of handles per type */
258 ppiList = gppiList;
259 while (ppiList)
260 {
261 ERR("Process %s (%p) handles count: %d\n\t", ppiList->peProcess->ImageFileName, ppiList->peProcess->UniqueProcessId, ppiList->UserHandleCount);
262
263 for (i = 1 ;i < TYPE_CTYPES; i++)
264 {
265 HandleCounts[i] += ppiList->DbgHandleCount[i];
266
267 DbgPrint("%S: %lu, ", TypeNames[i], ppiList->DbgHandleCount[i]);
268 if (i % 6 == 0)
269 DbgPrint("\n\t");
270 }
271 DbgPrint("\n");
272
273 ppiList = ppiList->ppiNext;
274 }
275
276 /* Print total type counts */
277 ERR("Total handles of the running processes: \n\t");
278 for (i = 1 ;i < TYPE_CTYPES; i++)
279 {
280 DbgPrint("%S: %d, ", TypeNames[i], HandleCounts[i]);
281 if (i % 6 == 0)
282 DbgPrint("\n\t");
283 }
284 DbgPrint("\n");
285
286 /* Now count the handle counts that are allocated from the handle table */
287 memset(HandleCounts, 0, sizeof(HandleCounts));
288 for (i = 0; i < gHandleTable->nb_handles; i++)
289 HandleCounts[gHandleTable->handles[i].type]++;
290
291 ERR("Total handles count allocated: \n\t");
292 for (i = 1 ;i < TYPE_CTYPES; i++)
293 {
294 DbgPrint("%S: %d, ", TypeNames[i], HandleCounts[i]);
295 if (i % 6 == 0)
296 DbgPrint("\n\t");
297 }
298 DbgPrint("\n");
299 }
300
301 #endif
302
303 PUSER_HANDLE_ENTRY handle_to_entry(PUSER_HANDLE_TABLE ht, HANDLE handle )
304 {
305 unsigned short generation;
306 int index = (((unsigned int)handle & 0xffff) - FIRST_USER_HANDLE) >> 1;
307 if (index < 0 || index >= ht->nb_handles)
308 return NULL;
309 if (!ht->handles[index].type)
310 return NULL;
311 generation = (unsigned int)handle >> 16;
312 if (generation == ht->handles[index].generation || !generation || generation == 0xffff)
313 return &ht->handles[index];
314 return NULL;
315 }
316
317 __inline static HANDLE entry_to_handle(PUSER_HANDLE_TABLE ht, PUSER_HANDLE_ENTRY ptr )
318 {
319 int index = ptr - ht->handles;
320 return (HANDLE)(((index << 1) + FIRST_USER_HANDLE) + (ptr->generation << 16));
321 }
322
323 __inline static PUSER_HANDLE_ENTRY alloc_user_entry(PUSER_HANDLE_TABLE ht)
324 {
325 PUSER_HANDLE_ENTRY entry;
326 TRACE("handles used %lu\n", gpsi->cHandleEntries);
327
328 if (ht->freelist)
329 {
330 entry = ht->freelist;
331 ht->freelist = entry->ptr;
332
333 gpsi->cHandleEntries++;
334 return entry;
335 }
336
337 if (ht->nb_handles >= ht->allocated_handles) /* Need to grow the array */
338 {
339 ERR("Out of user handles! Used -> %lu, NM_Handle -> %d\n", gpsi->cHandleEntries, ht->nb_handles);
340
341 #if DBG
342 DbgUserDumpHandleTable();
343 #endif
344
345 return NULL;
346 #if 0
347 PUSER_HANDLE_ENTRY new_handles;
348 /* Grow array by 50% (but at minimum 32 entries) */
349 int growth = max( 32, ht->allocated_handles / 2 );
350 int new_size = min( ht->allocated_handles + growth, (LAST_USER_HANDLE-FIRST_USER_HANDLE+1) >> 1 );
351 if (new_size <= ht->allocated_handles)
352 return NULL;
353 if (!(new_handles = UserHeapReAlloc( ht->handles, new_size * sizeof(*ht->handles) )))
354 return NULL;
355 ht->handles = new_handles;
356 ht->allocated_handles = new_size;
357 #endif
358 }
359
360 entry = &ht->handles[ht->nb_handles++];
361
362 entry->generation = 1;
363
364 gpsi->cHandleEntries++;
365
366 return entry;
367 }
368
369 VOID UserInitHandleTable(PUSER_HANDLE_TABLE ht, PVOID mem, ULONG bytes)
370 {
371 ht->freelist = NULL;
372 ht->handles = mem;
373
374 ht->nb_handles = 0;
375 ht->allocated_handles = bytes / sizeof(USER_HANDLE_ENTRY);
376 }
377
378
379 __inline static void *free_user_entry(PUSER_HANDLE_TABLE ht, PUSER_HANDLE_ENTRY entry)
380 {
381 void *ret;
382
383 #if DBG
384 {
385 PPROCESSINFO ppi;
386 switch (entry->type)
387 {
388 case TYPE_WINDOW:
389 case TYPE_HOOK:
390 case TYPE_WINEVENTHOOK:
391 ppi = ((PTHREADINFO)entry->pi)->ppi;
392 break;
393 case TYPE_MENU:
394 case TYPE_CURSOR:
395 case TYPE_CALLPROC:
396 case TYPE_ACCELTABLE:
397 ppi = entry->pi;
398 break;
399 default:
400 ppi = NULL;
401 }
402 if (ppi)
403 ppi->DbgHandleCount[entry->type]--;
404 }
405 #endif
406
407 ret = entry->ptr;
408 entry->ptr = ht->freelist;
409 entry->type = 0;
410 entry->flags = 0;
411 entry->pi = NULL;
412 ht->freelist = entry;
413
414 gpsi->cHandleEntries--;
415
416 return ret;
417 }
418
419 /* allocate a user handle for a given object */
420 HANDLE UserAllocHandle(
421 _Inout_ PUSER_HANDLE_TABLE ht,
422 _In_ PVOID object,
423 _In_ HANDLE_TYPE type,
424 _In_ PVOID HandleOwner)
425 {
426 PUSER_HANDLE_ENTRY entry = alloc_user_entry(ht);
427 if (!entry)
428 return 0;
429 entry->ptr = object;
430 entry->type = type;
431 entry->flags = 0;
432 entry->pi = HandleOwner;
433 if (++entry->generation >= 0xffff)
434 entry->generation = 1;
435
436 /* We have created a handle, which is a reference! */
437 UserReferenceObject(object);
438
439 return entry_to_handle(ht, entry );
440 }
441
442 /* return a pointer to a user object from its handle without setting an error */
443 PVOID UserGetObjectNoErr(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type )
444 {
445 PUSER_HANDLE_ENTRY entry;
446
447 ASSERT(ht);
448
449 if (!(entry = handle_to_entry(ht, handle )) || entry->type != type)
450 {
451 return NULL;
452 }
453 return entry->ptr;
454 }
455
456 /* return a pointer to a user object from its handle */
457 PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type )
458 {
459 PUSER_HANDLE_ENTRY entry;
460
461 ASSERT(ht);
462
463 if (!(entry = handle_to_entry(ht, handle )) || entry->type != type)
464 {
465 EngSetLastError(ERROR_INVALID_HANDLE);
466 return NULL;
467 }
468 return entry->ptr;
469 }
470
471
472 /* Get the full handle (32bit) for a possibly truncated (16bit) handle */
473 HANDLE get_user_full_handle(PUSER_HANDLE_TABLE ht, HANDLE handle )
474 {
475 PUSER_HANDLE_ENTRY entry;
476
477 if ((unsigned int)handle >> 16)
478 return handle;
479 if (!(entry = handle_to_entry(ht, handle )))
480 return handle;
481 return entry_to_handle( ht, entry );
482 }
483
484
485 /* Same as get_user_object plus set the handle to the full 32-bit value */
486 void *get_user_object_handle(PUSER_HANDLE_TABLE ht, HANDLE* handle, HANDLE_TYPE type )
487 {
488 PUSER_HANDLE_ENTRY entry;
489
490 if (!(entry = handle_to_entry(ht, *handle )) || entry->type != type)
491 return NULL;
492 *handle = entry_to_handle( ht, entry );
493 return entry->ptr;
494 }
495
496
497
498 BOOL FASTCALL UserCreateHandleTable(VOID)
499 {
500 PVOID mem;
501 INT HandleCount = 1024 * 4;
502
503 // FIXME: Don't alloc all at once! Must be mapped into umode also...
504 mem = UserHeapAlloc(sizeof(USER_HANDLE_ENTRY) * HandleCount);
505 if (!mem)
506 {
507 ERR("Failed creating handle table\n");
508 return FALSE;
509 }
510
511 gHandleTable = UserHeapAlloc(sizeof(USER_HANDLE_TABLE));
512 if (gHandleTable == NULL)
513 {
514 UserHeapFree(mem);
515 ERR("Failed creating handle table\n");
516 return FALSE;
517 }
518
519 // FIXME: Make auto growable
520 UserInitHandleTable(gHandleTable, mem, sizeof(USER_HANDLE_ENTRY) * HandleCount);
521
522 return TRUE;
523 }
524
525 //
526 // New
527 //
528 PVOID
529 FASTCALL
530 UserCreateObject( PUSER_HANDLE_TABLE ht,
531 PDESKTOP pDesktop,
532 PTHREADINFO pti,
533 HANDLE* h,
534 HANDLE_TYPE type,
535 ULONG size)
536 {
537 HANDLE hi;
538 PVOID Object;
539 PVOID ObjectOwner;
540
541 /* Some sanity checks. Other checks will be made in the allocator */
542 ASSERT(type < TYPE_CTYPES);
543 ASSERT(type != TYPE_FREE);
544 ASSERT(ht != NULL);
545
546 /* Allocate the object */
547 ASSERT(ObjectCallbacks[type].ObjectAlloc != NULL);
548 Object = ObjectCallbacks[type].ObjectAlloc(pDesktop, pti, size, &ObjectOwner);
549 if (!Object)
550 {
551 ERR("User object allocation failed. Out of memory!\n");
552 return NULL;
553 }
554
555 hi = UserAllocHandle(ht, Object, type, ObjectOwner);
556 if (hi == NULL)
557 {
558 ERR("Out of user handles!\n");
559 ObjectCallbacks[type].ObjectFree(Object);
560 return NULL;
561 }
562
563 #if DBG
564 if (pti)
565 pti->ppi->DbgHandleCount[type]++;
566 #endif
567
568 /* Give this object its identity. */
569 ((PHEAD)Object)->h = hi;
570
571 /* The caller will get a locked object.
572 * Note: with the reference from the handle, that makes two */
573 UserReferenceObject(Object);
574
575 if (h)
576 *h = hi;
577 return Object;
578 }
579
580
581 BOOL
582 FASTCALL
583 UserDereferenceObject(PVOID Object)
584 {
585 PHEAD ObjHead = (PHEAD)Object;
586
587 ASSERT(ObjHead->cLockObj >= 1);
588
589 if (--ObjHead->cLockObj == 0)
590 {
591 PUSER_HANDLE_ENTRY entry;
592 HANDLE_TYPE type;
593
594 entry = handle_to_entry(gHandleTable, ObjHead->h);
595
596 ASSERT(entry != NULL);
597 /* The entry should be marked as in deletion */
598 ASSERT(entry->flags & HANDLEENTRY_INDESTROY);
599
600 type = entry->type;
601 ASSERT(type != TYPE_FREE);
602 ASSERT(type < TYPE_CTYPES);
603
604 /* We can now get rid of everything */
605 free_user_entry(gHandleTable, entry );
606
607 #if 0
608 /* Call the object destructor */
609 ASSERT(ObjectCallbacks[type].ObjectCleanup != NULL);
610 ObjectCallbacks[type].ObjectCleanup(Object);
611 #endif
612
613 /* And free it */
614 ASSERT(ObjectCallbacks[type].ObjectFree != NULL);
615 ObjectCallbacks[type].ObjectFree(Object);
616
617 return TRUE;
618 }
619 return FALSE;
620 }
621
622 BOOL
623 FASTCALL
624 UserFreeHandle(PUSER_HANDLE_TABLE ht, HANDLE handle )
625 {
626 PUSER_HANDLE_ENTRY entry;
627
628 if (!(entry = handle_to_entry( ht, handle )))
629 {
630 SetLastNtError( STATUS_INVALID_HANDLE );
631 return FALSE;
632 }
633
634 entry->flags = HANDLEENTRY_INDESTROY;
635
636 return UserDereferenceObject(entry->ptr);
637 }
638
639 BOOL
640 FASTCALL
641 UserObjectInDestroy(HANDLE h)
642 {
643 PUSER_HANDLE_ENTRY entry;
644
645 if (!(entry = handle_to_entry( gHandleTable, h )))
646 {
647 SetLastNtError( STATUS_INVALID_HANDLE );
648 return TRUE;
649 }
650 return (entry->flags & HANDLEENTRY_INDESTROY);
651 }
652
653 BOOL
654 FASTCALL
655 UserDeleteObject(HANDLE h, HANDLE_TYPE type )
656 {
657 PVOID body = UserGetObject(gHandleTable, h, type);
658
659 if (!body) return FALSE;
660
661 ASSERT( ((PHEAD)body)->cLockObj >= 1);
662
663 return UserFreeHandle(gHandleTable, h);
664 }
665
666 VOID
667 FASTCALL
668 UserReferenceObject(PVOID obj)
669 {
670 ASSERT(((PHEAD)obj)->cLockObj >= 0);
671
672 ((PHEAD)obj)->cLockObj++;
673 }
674
675 PVOID
676 FASTCALL
677 UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type)
678 {
679 PVOID object;
680
681 object = UserGetObject(gHandleTable, handle, type);
682 if (object)
683 {
684 UserReferenceObject(object);
685 }
686 return object;
687 }
688
689 VOID
690 FASTCALL
691 UserSetObjectOwner(PVOID obj, HANDLE_TYPE type, PVOID owner)
692 {
693 PUSER_HANDLE_ENTRY entry = handle_to_entry(gHandleTable, ((PHEAD)obj)->h );
694 PPROCESSINFO ppi, oldppi;
695
696 /* This must be called with a valid object */
697 ASSERT(entry);
698
699 /* For now, only supported for CursorIcon object */
700 switch(type)
701 {
702 case TYPE_CURSOR:
703 ppi = (PPROCESSINFO)owner;
704 entry->pi = ppi;
705 oldppi = ((PPROCMARKHEAD)obj)->ppi;
706 ((PPROCMARKHEAD)obj)->ppi = ppi;
707 break;
708 default:
709 ASSERT(FALSE);
710 return;
711 }
712
713 #if DBG
714 oldppi->DbgHandleCount[type]--;
715 ppi->DbgHandleCount[type]++;
716 #endif
717
718 oldppi->UserHandleCount--;
719 IntDereferenceProcessInfo(oldppi);
720 ppi->UserHandleCount++;
721 IntReferenceProcessInfo(ppi);
722 }
723
724 BOOLEAN
725 UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner)
726 {
727 int i;
728 PUSER_HANDLE_ENTRY Entry;
729 BOOLEAN Ret = TRUE;
730
731 /* Sweep the whole handle table */
732 for (i = 0; i < Table->allocated_handles; i++)
733 {
734 Entry = &Table->handles[i];
735
736 if (Entry->pi != Owner)
737 continue;
738
739 /* Do not destroy if it's already been done */
740 if (Entry->flags & HANDLEENTRY_INDESTROY)
741 continue;
742
743 /* Spcial case for cursors until cursoricon_new is there */
744 if (Entry->type == TYPE_CURSOR)
745 {
746 UserReferenceObject(Entry->ptr);
747 if (!IntDestroyCurIconObject(Entry->ptr, Owner))
748 {
749 Ret = FALSE;
750 }
751 continue;
752 }
753
754 /* Call destructor */
755 if (!ObjectCallbacks[Entry->type].ObjectDestroy(Entry->ptr))
756 {
757 ERR("Failed destructing object %p, type %u.\n", Entry->ptr, Entry->type);
758 /* Don't return immediately, we must continue destroying the other objects */
759 Ret = FALSE;
760 }
761 }
762
763 return Ret;
764 }
765
766 /*
767 * NtUserValidateHandleSecure W2k3 has one argument.
768 *
769 * Status
770 * @implemented
771 */
772
773 BOOL
774 APIENTRY
775 NtUserValidateHandleSecure(
776 HANDLE handle,
777 BOOL Restricted)
778 {
779 UINT uType;
780 PPROCESSINFO ppi;
781 PUSER_HANDLE_ENTRY entry;
782
783 DECLARE_RETURN(BOOL);
784 UserEnterExclusive();
785
786 if (!(entry = handle_to_entry(gHandleTable, handle )))
787 {
788 EngSetLastError(ERROR_INVALID_HANDLE);
789 RETURN( FALSE);
790 }
791 uType = entry->type;
792 switch (uType)
793 {
794 case TYPE_WINDOW:
795 case TYPE_INPUTCONTEXT:
796 ppi = ((PTHREADINFO)entry->pi)->ppi;
797 break;
798 case TYPE_MENU:
799 case TYPE_ACCELTABLE:
800 case TYPE_CURSOR:
801 case TYPE_HOOK:
802 case TYPE_CALLPROC:
803 case TYPE_SETWINDOWPOS:
804 ppi = entry->pi;
805 break;
806 default:
807 ppi = NULL;
808 break;
809 }
810
811 if (!ppi) RETURN( FALSE);
812
813 // Same process job returns TRUE.
814 if (gptiCurrent->ppi->pW32Job == ppi->pW32Job) RETURN( TRUE);
815
816 RETURN( FALSE);
817
818 CLEANUP:
819 UserLeave();
820 END_CLEANUP;
821 }