bost the drv number to 5.03.2600.2180 for directx
[reactos.git] / reactos / ntoskrnl / ob / handle.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id$
20 *
21 * COPYRIGHT: See COPYING in the top level directory
22 * PROJECT: ReactOS kernel
23 * FILE: ntoskrnl/ob/handle.c
24 * PURPOSE: Managing handles
25 * PROGRAMMER: David Welch (welch@cwcom.net)
26 * REVISION HISTORY:
27 * 17/06/98: Created
28 */
29
30 /* INCLUDES ****************************************************************/
31
32 #include <ntoskrnl.h>
33 #define NDEBUG
34 #include <internal/debug.h>
35
36 #define GENERIC_ANY (GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL)
37
38 /* GLOBALS *****************************************************************/
39
40 PHANDLE_TABLE ObpKernelHandleTable = NULL;
41
42 /* TEMPORARY HACK. DO NOT REMOVE -- Alex */
43 NTSTATUS
44 STDCALL
45 ExpDesktopCreate(PVOID ObjectBody,
46 PVOID Parent,
47 PWSTR RemainingPath,
48 POBJECT_CREATE_INFORMATION ObjectCreateInformation);
49
50 /* FUNCTIONS ***************************************************************/
51
52 static VOID
53 ObpDecrementHandleCount(PVOID ObjectBody)
54 {
55 POBJECT_HEADER ObjectHeader = BODY_TO_HEADER(ObjectBody);
56 LONG NewHandleCount = InterlockedDecrement(&ObjectHeader->HandleCount);
57 DPRINT("Header: %x\n", ObjectHeader);
58 DPRINT("NewHandleCount: %x\n", NewHandleCount);
59 DPRINT("HEADER_TO_OBJECT_NAME: %x\n", HEADER_TO_OBJECT_NAME(ObjectHeader));
60
61 if ((ObjectHeader->Type != NULL) &&
62 (ObjectHeader->Type->TypeInfo.CloseProcedure != NULL))
63 {
64 /* the handle count should be decremented but we pass the previous value
65 to the callback */
66 ObjectHeader->Type->TypeInfo.CloseProcedure(ObjectBody, NewHandleCount + 1);
67 }
68
69 if(NewHandleCount == 0)
70 {
71 if(HEADER_TO_OBJECT_NAME(ObjectHeader) &&
72 HEADER_TO_OBJECT_NAME(ObjectHeader)->Directory != NULL &&
73 !(ObjectHeader->Flags & OB_FLAG_PERMANENT))
74 {
75 /* delete the object from the namespace when the last handle got closed.
76 Only do this if it's actually been inserted into the namespace and
77 if it's not a permanent object. */
78 ObpRemoveEntryDirectory(ObjectHeader);
79 }
80
81 /* remove the keep-alive reference */
82 ObDereferenceObject(ObjectBody);
83 }
84 }
85
86
87 NTSTATUS
88 NTAPI
89 ObpQueryHandleAttributes(HANDLE Handle,
90 POBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo)
91 {
92 PHANDLE_TABLE HandleTable;
93 PHANDLE_TABLE_ENTRY HandleTableEntry;
94
95 PAGED_CODE();
96
97 DPRINT("ObpQueryHandleAttributes(Handle %x)\n", Handle);
98
99 if(ObIsKernelHandle(Handle, ExGetPreviousMode()))
100 {
101 HandleTable = ObpKernelHandleTable;
102 Handle = ObKernelHandleToHandle(Handle);
103 }
104 else
105 {
106 HandleTable = PsGetCurrentProcess()->ObjectTable;
107 }
108
109 KeEnterCriticalRegion();
110
111 HandleTableEntry = ExMapHandleToPointer(HandleTable,
112 Handle);
113 if (HandleTableEntry == NULL)
114 {
115 KeLeaveCriticalRegion();
116 return STATUS_INVALID_HANDLE;
117 }
118
119 HandleInfo->Inherit = (HandleTableEntry->u1.ObAttributes & EX_HANDLE_ENTRY_INHERITABLE) != 0;
120 HandleInfo->ProtectFromClose = (HandleTableEntry->u1.ObAttributes & EX_HANDLE_ENTRY_PROTECTFROMCLOSE) != 0;
121
122 ExUnlockHandleTableEntry(HandleTable,
123 HandleTableEntry);
124
125 KeLeaveCriticalRegion();
126
127 return STATUS_SUCCESS;
128 }
129
130
131 NTSTATUS
132 NTAPI
133 ObpSetHandleAttributes(HANDLE Handle,
134 POBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo)
135 {
136 PHANDLE_TABLE HandleTable;
137 PHANDLE_TABLE_ENTRY HandleTableEntry;
138
139 PAGED_CODE();
140
141 DPRINT("ObpSetHandleAttributes(Handle %x)\n", Handle);
142
143 if(ObIsKernelHandle(Handle, ExGetPreviousMode()))
144 {
145 HandleTable = ObpKernelHandleTable;
146 Handle = ObKernelHandleToHandle(Handle);
147 }
148 else
149 {
150 HandleTable = PsGetCurrentProcess()->ObjectTable;
151 }
152
153 KeEnterCriticalRegion();
154
155 HandleTableEntry = ExMapHandleToPointer(HandleTable,
156 Handle);
157 if (HandleTableEntry == NULL)
158 {
159 KeLeaveCriticalRegion();
160 return STATUS_INVALID_HANDLE;
161 }
162
163 if (HandleInfo->Inherit)
164 HandleTableEntry->u1.ObAttributes |= EX_HANDLE_ENTRY_INHERITABLE;
165 else
166 HandleTableEntry->u1.ObAttributes &= ~EX_HANDLE_ENTRY_INHERITABLE;
167
168 if (HandleInfo->ProtectFromClose)
169 HandleTableEntry->u1.ObAttributes |= EX_HANDLE_ENTRY_PROTECTFROMCLOSE;
170 else
171 HandleTableEntry->u1.ObAttributes &= ~EX_HANDLE_ENTRY_PROTECTFROMCLOSE;
172
173 /* FIXME: Do we need to set anything in the object header??? */
174
175 ExUnlockHandleTableEntry(HandleTable,
176 HandleTableEntry);
177
178 KeLeaveCriticalRegion();
179
180 return STATUS_SUCCESS;
181 }
182
183
184 static NTSTATUS
185 ObpDeleteHandle(PHANDLE_TABLE HandleTable,
186 HANDLE Handle)
187 {
188 PHANDLE_TABLE_ENTRY HandleEntry;
189 PVOID Body;
190 POBJECT_HEADER ObjectHeader;
191
192 PAGED_CODE();
193
194 DPRINT("ObpDeleteHandle(Handle %x)\n",Handle);
195
196 KeEnterCriticalRegion();
197
198 HandleEntry = ExMapHandleToPointer(HandleTable,
199 Handle);
200 if(HandleEntry != NULL)
201 {
202 if(HandleEntry->u1.ObAttributes & EX_HANDLE_ENTRY_PROTECTFROMCLOSE)
203 {
204 ExUnlockHandleTableEntry(HandleTable,
205 HandleEntry);
206
207 KeLeaveCriticalRegion();
208
209 return STATUS_HANDLE_NOT_CLOSABLE;
210 }
211
212 ObjectHeader = EX_HTE_TO_HDR(HandleEntry);
213 Body = &ObjectHeader->Body;
214
215 ObpDecrementHandleCount(Body);
216
217 /* destroy and unlock the handle entry */
218 ExDestroyHandleByEntry(HandleTable,
219 HandleEntry,
220 Handle);
221
222 KeLeaveCriticalRegion();
223
224 return STATUS_SUCCESS;
225 }
226 KeLeaveCriticalRegion();
227 return STATUS_INVALID_HANDLE;
228 }
229
230
231 NTSTATUS
232 NTAPI
233 ObDuplicateObject(PEPROCESS SourceProcess,
234 PEPROCESS TargetProcess,
235 HANDLE SourceHandle,
236 PHANDLE TargetHandle,
237 ACCESS_MASK DesiredAccess,
238 BOOLEAN InheritHandle,
239 ULONG Options)
240 {
241 PHANDLE_TABLE SourceHandleTable;
242 PHANDLE_TABLE_ENTRY SourceHandleEntry;
243 HANDLE_TABLE_ENTRY NewHandleEntry;
244 PVOID ObjectBody;
245 POBJECT_HEADER ObjectHeader;
246 ULONG NewHandleCount;
247 HANDLE NewTargetHandle;
248
249 PAGED_CODE();
250
251 if(ObIsKernelHandle(SourceHandle, ExGetPreviousMode()))
252 {
253 SourceHandleTable = ObpKernelHandleTable;
254 SourceHandle = ObKernelHandleToHandle(SourceHandle);
255 }
256 else
257 {
258 SourceHandleTable = SourceProcess->ObjectTable;
259 }
260
261 KeEnterCriticalRegion();
262
263 SourceHandleEntry = ExMapHandleToPointer(SourceHandleTable,
264 SourceHandle);
265 if (SourceHandleEntry == NULL)
266 {
267 KeLeaveCriticalRegion();
268 return STATUS_INVALID_HANDLE;
269 }
270
271 ObjectHeader = EX_HTE_TO_HDR(SourceHandleEntry);
272 ObjectBody = &ObjectHeader->Body;
273
274 NewHandleEntry.u1.Object = SourceHandleEntry->u1.Object;
275 if(InheritHandle)
276 NewHandleEntry.u1.ObAttributes |= EX_HANDLE_ENTRY_INHERITABLE;
277 else
278 NewHandleEntry.u1.ObAttributes &= ~EX_HANDLE_ENTRY_INHERITABLE;
279 NewHandleEntry.u2.GrantedAccess = ((Options & DUPLICATE_SAME_ACCESS) ?
280 SourceHandleEntry->u2.GrantedAccess :
281 DesiredAccess);
282 if (Options & DUPLICATE_SAME_ACCESS)
283 {
284 NewHandleEntry.u2.GrantedAccess = SourceHandleEntry->u2.GrantedAccess;
285 }
286 else
287 {
288 if (DesiredAccess & GENERIC_ANY)
289 {
290 RtlMapGenericMask(&DesiredAccess,
291 &ObjectHeader->Type->TypeInfo.GenericMapping);
292 }
293 NewHandleEntry.u2.GrantedAccess = DesiredAccess;
294 }
295
296 /* reference the object so it doesn't get deleted after releasing the lock
297 and before creating a new handle for it */
298 ObReferenceObject(ObjectBody);
299
300 /* increment the handle count of the object, it should always be >= 2 because
301 we're holding a handle lock to this object! if the new handle count was
302 1 here, we're in big trouble... it would've been safe to increment and
303 check the handle count without using interlocked functions because the
304 entry is locked, which means the handle count can't change. */
305 NewHandleCount = InterlockedIncrement(&ObjectHeader->HandleCount);
306 ASSERT(NewHandleCount >= 2);
307
308 ExUnlockHandleTableEntry(SourceHandleTable,
309 SourceHandleEntry);
310
311 KeLeaveCriticalRegion();
312
313 /* attempt to create the new handle */
314 NewTargetHandle = ExCreateHandle(TargetProcess->ObjectTable,
315 &NewHandleEntry);
316 if (NewTargetHandle != NULL)
317 {
318 if (Options & DUPLICATE_CLOSE_SOURCE)
319 {
320 ObpDeleteHandle(SourceHandleTable,
321 SourceHandle);
322 }
323
324 ObDereferenceObject(ObjectBody);
325
326 *TargetHandle = NewTargetHandle;
327
328 return STATUS_SUCCESS;
329 }
330 else
331 {
332 /* decrement the handle count we previously incremented, but don't call the
333 closing procedure because we're not closing a handle! */
334 if(InterlockedDecrement(&ObjectHeader->HandleCount) == 0)
335 {
336 ObDereferenceObject(ObjectBody);
337 }
338
339 ObDereferenceObject(ObjectBody);
340 return STATUS_UNSUCCESSFUL;
341 }
342 }
343
344 /*
345 * @implemented
346 */
347 NTSTATUS STDCALL
348 NtDuplicateObject (IN HANDLE SourceProcessHandle,
349 IN HANDLE SourceHandle,
350 IN HANDLE TargetProcessHandle,
351 OUT PHANDLE TargetHandle OPTIONAL,
352 IN ACCESS_MASK DesiredAccess,
353 IN ULONG InheritHandle,
354 IN ULONG Options)
355 /*
356 * FUNCTION: Copies a handle from one process space to another
357 * ARGUMENTS:
358 * SourceProcessHandle = The source process owning the handle. The
359 * source process should have opened
360 * the SourceHandle with PROCESS_DUP_HANDLE
361 * access.
362 * SourceHandle = The handle to the object.
363 * TargetProcessHandle = The destination process owning the handle
364 * TargetHandle (OUT) = Caller should supply storage for the
365 * duplicated handle.
366 * DesiredAccess = The desired access to the handle.
367 * InheritHandle = Indicates wheter the new handle will be inheritable
368 * or not.
369 * Options = Specifies special actions upon duplicating the handle.
370 * Can be one of the values DUPLICATE_CLOSE_SOURCE |
371 * DUPLICATE_SAME_ACCESS. DUPLICATE_CLOSE_SOURCE specifies
372 * that the source handle should be closed after duplicating.
373 * DUPLICATE_SAME_ACCESS specifies to ignore the
374 * DesiredAccess paramter and just grant the same access to
375 * the new handle.
376 * RETURNS: Status
377 * REMARKS: This function maps to the win32 DuplicateHandle.
378 */
379 {
380 PEPROCESS SourceProcess;
381 PEPROCESS TargetProcess;
382 HANDLE hTarget;
383 KPROCESSOR_MODE PreviousMode;
384 NTSTATUS Status = STATUS_SUCCESS;
385
386 PAGED_CODE();
387
388 PreviousMode = ExGetPreviousMode();
389
390 if(TargetHandle != NULL && PreviousMode != KernelMode)
391 {
392 _SEH_TRY
393 {
394 ProbeForWriteHandle(TargetHandle);
395 }
396 _SEH_HANDLE
397 {
398 Status = _SEH_GetExceptionCode();
399 }
400 _SEH_END;
401
402 if(!NT_SUCCESS(Status))
403 {
404 return Status;
405 }
406 }
407
408 Status = ObReferenceObjectByHandle(SourceProcessHandle,
409 PROCESS_DUP_HANDLE,
410 NULL,
411 PreviousMode,
412 (PVOID*)&SourceProcess,
413 NULL);
414 if (!NT_SUCCESS(Status))
415 {
416 return(Status);
417 }
418
419 Status = ObReferenceObjectByHandle(TargetProcessHandle,
420 PROCESS_DUP_HANDLE,
421 NULL,
422 PreviousMode,
423 (PVOID*)&TargetProcess,
424 NULL);
425 if (!NT_SUCCESS(Status))
426 {
427 ObDereferenceObject(SourceProcess);
428 return(Status);
429 }
430
431 /* Check for magic handle first */
432 if (SourceHandle == NtCurrentThread() ||
433 SourceHandle == NtCurrentProcess())
434 {
435 PVOID ObjectBody;
436 POBJECT_TYPE ObjectType;
437
438 ObjectType = (SourceHandle == NtCurrentThread()) ? PsThreadType : PsProcessType;
439
440 Status = ObReferenceObjectByHandle(SourceHandle,
441 0,
442 ObjectType,
443 PreviousMode,
444 &ObjectBody,
445 NULL);
446 if(NT_SUCCESS(Status))
447 {
448 if (Options & DUPLICATE_SAME_ACCESS)
449 {
450 /* grant all access rights */
451 DesiredAccess = ((ObjectType == PsThreadType) ? THREAD_ALL_ACCESS : PROCESS_ALL_ACCESS);
452 }
453 else
454 {
455 if (DesiredAccess & GENERIC_ANY)
456 {
457 RtlMapGenericMask(&DesiredAccess,
458 &ObjectType->TypeInfo.GenericMapping);
459 }
460 }
461 Status = ObpCreateHandle(TargetProcess,
462 ObjectBody,
463 DesiredAccess,
464 InheritHandle,
465 &hTarget);
466
467 ObDereferenceObject(ObjectBody);
468
469 if (Options & DUPLICATE_CLOSE_SOURCE)
470 {
471 ObpDeleteHandle(SourceProcess->ObjectTable,
472 SourceHandle);
473 }
474 }
475 }
476 else
477 {
478 Status = ObDuplicateObject(SourceProcess,
479 TargetProcess,
480 SourceHandle,
481 &hTarget,
482 DesiredAccess,
483 InheritHandle,
484 Options);
485 }
486
487 ObDereferenceObject(TargetProcess);
488 ObDereferenceObject(SourceProcess);
489
490 if(NT_SUCCESS(Status) && TargetHandle != NULL)
491 {
492 _SEH_TRY
493 {
494 *TargetHandle = hTarget;
495 }
496 _SEH_HANDLE
497 {
498 Status = _SEH_GetExceptionCode();
499 }
500 _SEH_END;
501 }
502
503 return Status;
504 }
505
506 static VOID STDCALL
507 DeleteHandleCallback(PHANDLE_TABLE HandleTable,
508 PVOID Object,
509 ULONG GrantedAccess,
510 PVOID Context)
511 {
512 POBJECT_HEADER ObjectHeader;
513 PVOID ObjectBody;
514
515 PAGED_CODE();
516
517 ObjectHeader = EX_OBJ_TO_HDR(Object);
518 ObjectBody = &ObjectHeader->Body;
519
520 ObpDecrementHandleCount(ObjectBody);
521 }
522
523 static BOOLEAN STDCALL
524 DuplicateHandleCallback(PHANDLE_TABLE HandleTable,
525 PHANDLE_TABLE_ENTRY HandleTableEntry,
526 PVOID Context)
527 {
528 POBJECT_HEADER ObjectHeader;
529 BOOLEAN Ret = FALSE;
530
531 PAGED_CODE();
532
533 Ret = (HandleTableEntry->u1.ObAttributes & EX_HANDLE_ENTRY_INHERITABLE) != 0;
534 if(Ret)
535 {
536 ObjectHeader = EX_HTE_TO_HDR(HandleTableEntry);
537 if(InterlockedIncrement(&ObjectHeader->HandleCount) == 1)
538 {
539 ObReferenceObject(&ObjectHeader->Body);
540 }
541 }
542
543 return Ret;
544 }
545
546 VOID
547 NTAPI
548 ObCreateHandleTable(PEPROCESS Parent,
549 BOOLEAN Inherit,
550 PEPROCESS Process)
551 /*
552 * FUNCTION: Creates a handle table for a process
553 * ARGUMENTS:
554 * Parent = Parent process (or NULL if this is the first process)
555 * Inherit = True if the process should inherit its parent's handles
556 * Process = Process whose handle table is to be created
557 */
558 {
559 PAGED_CODE();
560
561 DPRINT("ObCreateHandleTable(Parent %x, Inherit %d, Process %x)\n",
562 Parent,Inherit,Process);
563 if(Parent != NULL)
564 {
565 Process->ObjectTable = ExDupHandleTable(Process,
566 DuplicateHandleCallback,
567 NULL,
568 Parent->ObjectTable);
569 }
570 else
571 {
572 Process->ObjectTable = ExCreateHandleTable(Process);
573 }
574 }
575
576
577 VOID
578 STDCALL
579 ObKillProcess(PEPROCESS Process)
580 {
581 PAGED_CODE();
582
583 ExDestroyHandleTable(Process->ObjectTable,
584 DeleteHandleCallback,
585 Process);
586 }
587
588
589 NTSTATUS
590 NTAPI
591 ObpCreateHandle(PEPROCESS Process,
592 PVOID ObjectBody,
593 ACCESS_MASK GrantedAccess,
594 BOOLEAN Inherit,
595 PHANDLE HandleReturn)
596 /*
597 * FUNCTION: Add a handle referencing an object
598 * ARGUMENTS:
599 * obj = Object body that the handle should refer to
600 * RETURNS: The created handle
601 * NOTE: The handle is valid only in the context of the current process
602 */
603 {
604 HANDLE_TABLE_ENTRY NewEntry;
605 POBJECT_HEADER ObjectHeader;
606 HANDLE Handle;
607
608 PAGED_CODE();
609
610 DPRINT("ObpCreateHandle(Process %x, obj %x)\n",Process,ObjectBody);
611
612 ASSERT(Process);
613 ASSERT(ObjectBody);
614
615 ObjectHeader = BODY_TO_HEADER(ObjectBody);
616
617 ASSERT((ULONG_PTR)ObjectHeader & EX_HANDLE_ENTRY_LOCKED);
618
619 if (GrantedAccess & MAXIMUM_ALLOWED)
620 {
621 GrantedAccess &= ~MAXIMUM_ALLOWED;
622 GrantedAccess |= GENERIC_ALL;
623 }
624
625 if (GrantedAccess & GENERIC_ANY)
626 {
627 RtlMapGenericMask(&GrantedAccess,
628 &ObjectHeader->Type->TypeInfo.GenericMapping);
629 }
630
631 NewEntry.u1.Object = ObjectHeader;
632 if(Inherit)
633 NewEntry.u1.ObAttributes |= EX_HANDLE_ENTRY_INHERITABLE;
634 else
635 NewEntry.u1.ObAttributes &= ~EX_HANDLE_ENTRY_INHERITABLE;
636 NewEntry.u2.GrantedAccess = GrantedAccess;
637
638 Handle = ExCreateHandle(Process->ObjectTable,
639 &NewEntry);
640 DPRINT("ObCreateHandle(0x%x)==0x%x [HT:0x%x]\n", ObjectHeader, Handle, Process->ObjectTable);
641 if(Handle != NULL)
642 {
643 if(InterlockedIncrement(&ObjectHeader->HandleCount) == 1)
644 {
645 ObReferenceObjectByPointer(ObjectBody,
646 0,
647 NULL,
648 UserMode);
649 }
650
651 *HandleReturn = Handle;
652
653 return STATUS_SUCCESS;
654 }
655
656 return STATUS_UNSUCCESSFUL;
657 }
658
659
660 /*
661 * @implemented
662 */
663 NTSTATUS STDCALL
664 ObQueryObjectAuditingByHandle(IN HANDLE Handle,
665 OUT PBOOLEAN GenerateOnClose)
666 {
667 PHANDLE_TABLE_ENTRY HandleEntry;
668 PEPROCESS Process;
669
670 PAGED_CODE();
671
672 DPRINT("ObQueryObjectAuditingByHandle(Handle %x)\n", Handle);
673
674 Process = PsGetCurrentProcess();
675
676 KeEnterCriticalRegion();
677
678 HandleEntry = ExMapHandleToPointer(Process->ObjectTable,
679 Handle);
680 if(HandleEntry != NULL)
681 {
682 *GenerateOnClose = (HandleEntry->u1.ObAttributes & EX_HANDLE_ENTRY_AUDITONCLOSE) != 0;
683
684 ExUnlockHandleTableEntry(Process->ObjectTable,
685 HandleEntry);
686
687 KeLeaveCriticalRegion();
688
689 return STATUS_SUCCESS;
690 }
691
692 KeLeaveCriticalRegion();
693
694 return STATUS_INVALID_HANDLE;
695 }
696
697
698 /*
699 * FUNCTION: Increments the reference count for an object and returns a
700 * pointer to its body
701 * ARGUMENTS:
702 * Handle = Handle for the object
703 * DesiredAccess = Desired access to the object
704 * ObjectType
705 * AccessMode
706 * Object (OUT) = Points to the object body on return
707 * HandleInformation (OUT) = Contains information about the handle
708 * on return
709 * RETURNS: Status
710 *
711 * @implemented
712 */
713 NTSTATUS STDCALL
714 ObReferenceObjectByHandle(HANDLE Handle,
715 ACCESS_MASK DesiredAccess,
716 POBJECT_TYPE ObjectType,
717 KPROCESSOR_MODE AccessMode,
718 PVOID* Object,
719 POBJECT_HANDLE_INFORMATION HandleInformation)
720 {
721 PHANDLE_TABLE_ENTRY HandleEntry;
722 POBJECT_HEADER ObjectHeader;
723 PHANDLE_TABLE HandleTable;
724 PVOID ObjectBody;
725 ACCESS_MASK GrantedAccess;
726 ULONG Attributes;
727
728 PAGED_CODE();
729
730 DPRINT("ObReferenceObjectByHandle(Handle %x, DesiredAccess %x, "
731 "ObjectType %x, AccessMode %d, Object %x)\n",Handle,DesiredAccess,
732 ObjectType,AccessMode,Object);
733
734 if (Handle == NULL)
735 {
736 return STATUS_INVALID_HANDLE;
737 }
738 /*
739 * Handle special handle names
740 */
741 if (Handle == NtCurrentProcess() &&
742 (ObjectType == PsProcessType || ObjectType == NULL))
743 {
744 PEPROCESS CurrentProcess = PsGetCurrentProcess();
745
746 ObReferenceObject(CurrentProcess);
747
748 if (HandleInformation != NULL)
749 {
750 HandleInformation->HandleAttributes = 0;
751 HandleInformation->GrantedAccess = PROCESS_ALL_ACCESS;
752 }
753
754 *Object = CurrentProcess;
755 DPRINT("Referencing current process %x\n", CurrentProcess);
756 return STATUS_SUCCESS;
757 }
758 else if (Handle == NtCurrentProcess())
759 {
760 CHECKPOINT;
761 return(STATUS_OBJECT_TYPE_MISMATCH);
762 }
763
764 if (Handle == NtCurrentThread() &&
765 (ObjectType == PsThreadType || ObjectType == NULL))
766 {
767 PETHREAD CurrentThread = PsGetCurrentThread();
768
769 ObReferenceObject(CurrentThread);
770
771 if (HandleInformation != NULL)
772 {
773 HandleInformation->HandleAttributes = 0;
774 HandleInformation->GrantedAccess = THREAD_ALL_ACCESS;
775 }
776
777 *Object = CurrentThread;
778 CHECKPOINT;
779 return STATUS_SUCCESS;
780 }
781 else if (Handle == NtCurrentThread())
782 {
783 CHECKPOINT;
784 return(STATUS_OBJECT_TYPE_MISMATCH);
785 }
786
787 /* desire as much access rights as possible */
788 if (DesiredAccess & MAXIMUM_ALLOWED)
789 {
790 DesiredAccess &= ~MAXIMUM_ALLOWED;
791 DesiredAccess |= GENERIC_ALL;
792 }
793
794 if(ObIsKernelHandle(Handle, AccessMode))
795 {
796 HandleTable = ObpKernelHandleTable;
797 Handle = ObKernelHandleToHandle(Handle);
798 }
799 else
800 {
801 HandleTable = PsGetCurrentProcess()->ObjectTable;
802 }
803
804 KeEnterCriticalRegion();
805
806 HandleEntry = ExMapHandleToPointer(HandleTable,
807 Handle);
808 if (HandleEntry == NULL)
809 {
810 KeLeaveCriticalRegion();
811 DPRINT("ExMapHandleToPointer() failed for handle 0x%x\n", Handle);
812 return(STATUS_INVALID_HANDLE);
813 }
814
815 ObjectHeader = EX_HTE_TO_HDR(HandleEntry);
816 ObjectBody = &ObjectHeader->Body;
817
818 DPRINT("locked1: ObjectHeader: 0x%x [HT:0x%x]\n", ObjectHeader, HandleTable);
819
820 if (ObjectType != NULL && ObjectType != ObjectHeader->Type)
821 {
822 DPRINT("ObjectType mismatch: %wZ vs %wZ (handle 0x%x)\n", &ObjectType->Name, ObjectHeader->Type ? &ObjectHeader->Type->Name : NULL, Handle);
823
824 ExUnlockHandleTableEntry(HandleTable,
825 HandleEntry);
826
827 KeLeaveCriticalRegion();
828
829 return(STATUS_OBJECT_TYPE_MISMATCH);
830 }
831
832 /* map the generic access masks if the caller asks for generic access */
833 if (DesiredAccess & GENERIC_ANY)
834 {
835 RtlMapGenericMask(&DesiredAccess,
836 &BODY_TO_HEADER(ObjectBody)->Type->TypeInfo.GenericMapping);
837 }
838
839 GrantedAccess = HandleEntry->u2.GrantedAccess;
840
841 /* Unless running as KernelMode, deny access if caller desires more access
842 rights than the handle can grant */
843 if(AccessMode != KernelMode && (~GrantedAccess & DesiredAccess))
844 {
845 ExUnlockHandleTableEntry(HandleTable,
846 HandleEntry);
847
848 KeLeaveCriticalRegion();
849
850 DPRINT1("GrantedAccess: 0x%x, ~GrantedAccess: 0x%x, DesiredAccess: 0x%x, denied: 0x%x\n", GrantedAccess, ~GrantedAccess, DesiredAccess, ~GrantedAccess & DesiredAccess);
851
852 return(STATUS_ACCESS_DENIED);
853 }
854
855 ObReferenceObject(ObjectBody);
856
857 Attributes = HandleEntry->u1.ObAttributes & (EX_HANDLE_ENTRY_PROTECTFROMCLOSE |
858 EX_HANDLE_ENTRY_INHERITABLE |
859 EX_HANDLE_ENTRY_AUDITONCLOSE);
860
861 ExUnlockHandleTableEntry(HandleTable,
862 HandleEntry);
863
864 KeLeaveCriticalRegion();
865
866 if (HandleInformation != NULL)
867 {
868 HandleInformation->HandleAttributes = Attributes;
869 HandleInformation->GrantedAccess = GrantedAccess;
870 }
871
872 *Object = ObjectBody;
873
874 return(STATUS_SUCCESS);
875 }
876
877
878 /**********************************************************************
879 * NAME EXPORTED
880 * NtClose
881 *
882 * DESCRIPTION
883 * Closes a handle reference to an object.
884 *
885 * ARGUMENTS
886 * Handle
887 * Handle to close.
888 *
889 * RETURN VALUE
890 * Status.
891 *
892 * @implemented
893 */
894 NTSTATUS STDCALL
895 NtClose(IN HANDLE Handle)
896 {
897 PHANDLE_TABLE HandleTable;
898 NTSTATUS Status;
899
900 PAGED_CODE();
901
902 if(ObIsKernelHandle(Handle, ExGetPreviousMode()))
903 {
904 HandleTable = ObpKernelHandleTable;
905 Handle = ObKernelHandleToHandle(Handle);
906 }
907 else
908 {
909 HandleTable = PsGetCurrentProcess()->ObjectTable;
910 }
911
912 Status = ObpDeleteHandle(HandleTable,
913 Handle);
914 if (!NT_SUCCESS(Status))
915 {
916 if((ExGetPreviousMode() != KernelMode) &&
917 (PsGetCurrentProcess()->ExceptionPort))
918 {
919 KeRaiseUserException(Status);
920 }
921 return Status;
922 }
923
924 return(STATUS_SUCCESS);
925 }
926
927
928 /*
929 * @implemented
930 */
931 NTSTATUS
932 STDCALL
933 ObInsertObject(IN PVOID Object,
934 IN PACCESS_STATE PassedAccessState OPTIONAL,
935 IN ACCESS_MASK DesiredAccess,
936 IN ULONG AdditionalReferences,
937 OUT PVOID* ReferencedObject OPTIONAL,
938 OUT PHANDLE Handle)
939 {
940 POBJECT_CREATE_INFORMATION ObjectCreateInfo;
941 POBJECT_HEADER Header;
942 POBJECT_HEADER_NAME_INFO ObjectNameInfo;
943 PVOID FoundObject = NULL;
944 POBJECT_HEADER FoundHeader = NULL;
945 NTSTATUS Status = STATUS_SUCCESS;
946 UNICODE_STRING RemainingPath;
947 BOOLEAN ObjectAttached = FALSE;
948 PSECURITY_DESCRIPTOR NewSecurityDescriptor = NULL;
949 SECURITY_SUBJECT_CONTEXT SubjectContext;
950
951 PAGED_CODE();
952
953 /* Get the Header and Create Info */
954 DPRINT("ObInsertObject: %x\n", Object);
955 Header = BODY_TO_HEADER(Object);
956 ObjectCreateInfo = Header->ObjectCreateInfo;
957 ObjectNameInfo = HEADER_TO_OBJECT_NAME(Header);
958
959 /* First try to find the Object */
960 if (ObjectNameInfo && ObjectNameInfo->Name.Buffer)
961 {
962 DPRINT("Object has a name. Trying to find it: %wZ.\n", &ObjectNameInfo->Name);
963 Status = ObFindObject(ObjectCreateInfo,
964 &ObjectNameInfo->Name,
965 &FoundObject,
966 &RemainingPath,
967 NULL);
968 DPRINT("FoundObject: %x, Path: %wZ\n", FoundObject, &RemainingPath);
969 if (!NT_SUCCESS(Status))
970 {
971 DPRINT1("ObFindObject() failed! (Status 0x%x)\n", Status);
972 return Status;
973 }
974
975 if (FoundObject)
976 {
977 DPRINT("Getting header: %x\n", FoundObject);
978 FoundHeader = BODY_TO_HEADER(FoundObject);
979 }
980
981 if (FoundHeader && RemainingPath.Buffer == NULL)
982 {
983 DPRINT("Object exists\n");
984 ObDereferenceObject(FoundObject);
985 return STATUS_OBJECT_NAME_COLLISION;
986 }
987 }
988 else
989 {
990 DPRINT("No name, empty remaining path\n");
991 RtlInitUnicodeString(&RemainingPath, NULL);
992 }
993
994 if (FoundHeader && FoundHeader->Type == ObDirectoryType &&
995 RemainingPath.Buffer)
996 {
997 /* The name was changed so let's update it */
998 /* FIXME: TEMPORARY HACK This will go in ObFindObject in the next commit */
999 PVOID NewName;
1000 PWSTR BufferPos = RemainingPath.Buffer;
1001 ULONG Delta = 0;
1002
1003 ObpAddEntryDirectory(FoundObject, Header, NULL);
1004 ObjectAttached = TRUE;
1005
1006 ObjectNameInfo = HEADER_TO_OBJECT_NAME(Header);
1007
1008 if (BufferPos[0] == L'\\')
1009 {
1010 BufferPos++;
1011 Delta = sizeof(WCHAR);
1012 }
1013 NewName = ExAllocatePool(NonPagedPool, RemainingPath.MaximumLength - Delta);
1014 RtlMoveMemory(NewName, BufferPos, RemainingPath.MaximumLength - Delta);
1015 if (ObjectNameInfo->Name.Buffer) ExFreePool(ObjectNameInfo->Name.Buffer);
1016 ObjectNameInfo->Name.Buffer = NewName;
1017 ObjectNameInfo->Name.Length = RemainingPath.Length - Delta;
1018 ObjectNameInfo->Name.MaximumLength = RemainingPath.MaximumLength - Delta;
1019 DPRINT("Name: %S\n", ObjectNameInfo->Name.Buffer);
1020 }
1021
1022 if ((Header->Type == IoFileObjectType) ||
1023 (Header->Type == ExDesktopObjectType) ||
1024 (Header->Type->TypeInfo.OpenProcedure != NULL))
1025 {
1026 DPRINT("About to call Open Routine\n");
1027 if (Header->Type == IoFileObjectType)
1028 {
1029 /* TEMPORARY HACK. DO NOT TOUCH -- Alex */
1030 DPRINT("Calling IopCreateFile: %x\n", FoundObject);
1031 Status = IopCreateFile(&Header->Body,
1032 FoundObject,
1033 RemainingPath.Buffer,
1034 ObjectCreateInfo);
1035 DPRINT("Called IopCreateFile: %x\n", Status);
1036
1037 }
1038 else if (Header->Type == ExDesktopObjectType)
1039 {
1040 /* TEMPORARY HACK. DO NOT TOUCH -- Alex */
1041 DPRINT("Calling ExpDesktopCreate\n");
1042 Status = ExpDesktopCreate(&Header->Body,
1043 FoundObject,
1044 RemainingPath.Buffer,
1045 ObjectCreateInfo);
1046 }
1047 else if (Header->Type->TypeInfo.OpenProcedure != NULL)
1048 {
1049 DPRINT("Calling %x\n", Header->Type->TypeInfo.OpenProcedure);
1050 Status = Header->Type->TypeInfo.OpenProcedure(ObCreateHandle,
1051 &Header->Body,
1052 NULL,
1053 0,
1054 0);
1055 }
1056
1057 if (!NT_SUCCESS(Status))
1058 {
1059 DPRINT("Create Failed\n");
1060 if (ObjectAttached == TRUE)
1061 {
1062 ObpRemoveEntryDirectory(Header);
1063 }
1064 if (FoundObject)
1065 {
1066 ObDereferenceObject(FoundObject);
1067 }
1068 RtlFreeUnicodeString(&RemainingPath);
1069 return Status;
1070 }
1071 }
1072
1073 RtlFreeUnicodeString(&RemainingPath);
1074
1075 DPRINT("Security Assignment in progress\n");
1076 SeCaptureSubjectContext(&SubjectContext);
1077
1078 /* Build the new security descriptor */
1079 Status = SeAssignSecurity((FoundHeader != NULL) ? FoundHeader->SecurityDescriptor : NULL,
1080 (ObjectCreateInfo != NULL) ? ObjectCreateInfo->SecurityDescriptor : NULL,
1081 &NewSecurityDescriptor,
1082 (Header->Type == ObDirectoryType),
1083 &SubjectContext,
1084 &Header->Type->TypeInfo.GenericMapping,
1085 PagedPool);
1086
1087 if (NT_SUCCESS(Status))
1088 {
1089 DPRINT("NewSecurityDescriptor %p\n", NewSecurityDescriptor);
1090
1091 if (Header->Type->TypeInfo.SecurityProcedure != NULL)
1092 {
1093 /* Call the security method */
1094 Status = Header->Type->TypeInfo.SecurityProcedure(&Header->Body,
1095 AssignSecurityDescriptor,
1096 0,
1097 NewSecurityDescriptor,
1098 NULL,
1099 NULL,
1100 NonPagedPool,
1101 NULL);
1102 }
1103 else
1104 {
1105 /* Assign the security descriptor to the object header */
1106 Status = ObpAddSecurityDescriptor(NewSecurityDescriptor,
1107 &Header->SecurityDescriptor);
1108 DPRINT("Object security descriptor %p\n", Header->SecurityDescriptor);
1109 }
1110
1111 /* Release the new security descriptor */
1112 SeDeassignSecurity(&NewSecurityDescriptor);
1113 }
1114
1115 DPRINT("Security Complete\n");
1116 SeReleaseSubjectContext(&SubjectContext);
1117
1118 /* Create the Handle */
1119 /* HACKHACK: Because of ROS's incorrect startup, this can be called
1120 * without a valid Process until I finalize the startup patch,
1121 * so don't create a handle if this is the case. We also don't create
1122 * a handle if Handle is NULL when the Registry Code calls it, because
1123 * the registry code totally bastardizes the Ob and needs to be fixed
1124 */
1125 DPRINT("Creating handle\n");
1126 if (Handle != NULL)
1127 {
1128 Status = ObpCreateHandle(PsGetCurrentProcess(),
1129 &Header->Body,
1130 DesiredAccess,
1131 ObjectCreateInfo->Attributes & OBJ_INHERIT,
1132 Handle);
1133 DPRINT("handle Created: %d. refcount. handlecount %d %d\n",
1134 *Handle, Header->PointerCount, Header->HandleCount);
1135 }
1136
1137 /* We can delete the Create Info now */
1138 Header->ObjectCreateInfo = NULL;
1139 ObpReleaseCapturedAttributes(ObjectCreateInfo);
1140 ExFreePool(ObjectCreateInfo);
1141
1142 DPRINT("Status %x\n", Status);
1143 return Status;
1144 }
1145
1146
1147 ULONG
1148 NTAPI
1149 ObpGetHandleCountByHandleTable(PHANDLE_TABLE HandleTable)
1150 {
1151 return HandleTable->HandleCount;
1152 }
1153
1154 /*
1155 * FUNCTION: Searches the handle table of a specified process whether it contains a
1156 * valid handle to the Object we're looking for. If not, it'll create one.
1157 *
1158 * NOTES:
1159 * The parameters of this function is basically a mixture of some of the parameters
1160 * of ObReferenceObjectByHandle() and ObReferenceObjectByPointer(). A little thinking
1161 * about what this function does (by it's name) makes clear what parameters it requires.
1162 * For example the AccessMode parameter of ObReferenceObjectByHandle/Pointer() is not
1163 * required at all as it only has influence on the object security. This function doesn't
1164 * want to get access to an object, it just looks for a valid handle and if it can't find
1165 * one, it'll just create one. It wouldn't make sense to check for security again as the
1166 * caller already has a pointer to the object.
1167 *
1168 * A test on an XP machine shows that this prototype appears to be correct.
1169 *
1170 * ARGUMENTS:
1171 * Process = This parameter simply describes in which handle table we're looking
1172 * for a handle to the object.
1173 * Object = The object pointer that we're looking for
1174 * ObjectType = Just a sanity check as ObReferenceObjectByHandle() and
1175 * ObReferenceObjectByPointer() provides.
1176 * HandleInformation = This one has to be the opposite meaning of the usage in
1177 * ObReferenceObjectByHandle(). If we actually found a valid
1178 * handle in the table, we need to check against the information
1179 * provided so we make sure this handle has all access rights
1180 * (and attributes?!) we need. If they don't match, we can't
1181 * use this handle and keep looking because the caller is likely
1182 * to depend on these access rights.
1183 * HandleReturn = The last parameter is the same as in ObCreateHandle(). If we could
1184 * find a suitable handle in the handle table, return this handle, if
1185 * not, we'll just create one using ObCreateHandle() with all access
1186 * rights the caller needs.
1187 *
1188 * RETURNS: Status
1189 *
1190 * @unimplemented
1191 */
1192 NTSTATUS STDCALL
1193 ObFindHandleForObject(IN PEPROCESS Process,
1194 IN PVOID Object,
1195 IN POBJECT_TYPE ObjectType,
1196 IN POBJECT_HANDLE_INFORMATION HandleInformation,
1197 OUT PHANDLE HandleReturn)
1198 {
1199 DPRINT("ObFindHandleForObject is unimplemented!\n");
1200 return STATUS_UNSUCCESSFUL;
1201 }
1202
1203 VOID
1204 ObpGetNextHandleByProcessCount(PSYSTEM_HANDLE_TABLE_ENTRY_INFO pshi,
1205 PEPROCESS Process,
1206 int Count)
1207 {
1208 ULONG P;
1209 // KIRQL oldIrql;
1210
1211 // pshi->HandleValue;
1212
1213 /*
1214 This will never work with ROS! M$, I guess uses 0 -> 65535.
1215 Ros uses 0 -> 4294967295!
1216 */
1217
1218 P = (ULONG) Process->UniqueProcessId;
1219 pshi->UniqueProcessId = (USHORT) P;
1220
1221 // KeAcquireSpinLock( &Process->HandleTable.ListLock, &oldIrql );
1222
1223 // pshi->GrantedAccess;
1224 // pshi->Object;
1225 // pshi->TypeIndex;
1226 // pshi->HandleAttributes;
1227
1228 // KeReleaseSpinLock( &Process->HandleTable.ListLock, oldIrql );
1229
1230 return;
1231 }
1232
1233
1234
1235 /* EOF */