- Silence TCPIP.
[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 SweepHandleCallback(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 /* FIXME - Temporary hack: sweep and destroy here, needs to be fixed!!! */
584 ExSweepHandleTable(Process->ObjectTable,
585 SweepHandleCallback,
586 Process);
587 ExDestroyHandleTable(Process->ObjectTable);
588 Process->ObjectTable = NULL;
589 }
590
591
592 NTSTATUS
593 NTAPI
594 ObpCreateHandle(PEPROCESS Process,
595 PVOID ObjectBody,
596 ACCESS_MASK GrantedAccess,
597 BOOLEAN Inherit,
598 PHANDLE HandleReturn)
599 /*
600 * FUNCTION: Add a handle referencing an object
601 * ARGUMENTS:
602 * obj = Object body that the handle should refer to
603 * RETURNS: The created handle
604 * NOTE: The handle is valid only in the context of the current process
605 */
606 {
607 HANDLE_TABLE_ENTRY NewEntry;
608 POBJECT_HEADER ObjectHeader;
609 HANDLE Handle;
610
611 PAGED_CODE();
612
613 DPRINT("ObpCreateHandle(Process %x, obj %x)\n",Process,ObjectBody);
614
615 ASSERT(Process);
616 ASSERT(ObjectBody);
617
618 ObjectHeader = BODY_TO_HEADER(ObjectBody);
619
620 ASSERT((ULONG_PTR)ObjectHeader & EX_HANDLE_ENTRY_LOCKED);
621
622 if (GrantedAccess & MAXIMUM_ALLOWED)
623 {
624 GrantedAccess &= ~MAXIMUM_ALLOWED;
625 GrantedAccess |= GENERIC_ALL;
626 }
627
628 if (GrantedAccess & GENERIC_ANY)
629 {
630 RtlMapGenericMask(&GrantedAccess,
631 &ObjectHeader->Type->TypeInfo.GenericMapping);
632 }
633
634 NewEntry.u1.Object = ObjectHeader;
635 if(Inherit)
636 NewEntry.u1.ObAttributes |= EX_HANDLE_ENTRY_INHERITABLE;
637 else
638 NewEntry.u1.ObAttributes &= ~EX_HANDLE_ENTRY_INHERITABLE;
639 NewEntry.u2.GrantedAccess = GrantedAccess;
640
641 Handle = ExCreateHandle(Process->ObjectTable,
642 &NewEntry);
643 DPRINT("ObCreateHandle(0x%x)==0x%x [HT:0x%x]\n", ObjectHeader, Handle, Process->ObjectTable);
644 if(Handle != NULL)
645 {
646 if(InterlockedIncrement(&ObjectHeader->HandleCount) == 1)
647 {
648 ObReferenceObjectByPointer(ObjectBody,
649 0,
650 NULL,
651 UserMode);
652 }
653
654 *HandleReturn = Handle;
655
656 return STATUS_SUCCESS;
657 }
658
659 return STATUS_UNSUCCESSFUL;
660 }
661
662
663 /*
664 * @implemented
665 */
666 NTSTATUS STDCALL
667 ObQueryObjectAuditingByHandle(IN HANDLE Handle,
668 OUT PBOOLEAN GenerateOnClose)
669 {
670 PHANDLE_TABLE_ENTRY HandleEntry;
671 PEPROCESS Process;
672
673 PAGED_CODE();
674
675 DPRINT("ObQueryObjectAuditingByHandle(Handle %x)\n", Handle);
676
677 Process = PsGetCurrentProcess();
678
679 KeEnterCriticalRegion();
680
681 HandleEntry = ExMapHandleToPointer(Process->ObjectTable,
682 Handle);
683 if(HandleEntry != NULL)
684 {
685 *GenerateOnClose = (HandleEntry->u1.ObAttributes & EX_HANDLE_ENTRY_AUDITONCLOSE) != 0;
686
687 ExUnlockHandleTableEntry(Process->ObjectTable,
688 HandleEntry);
689
690 KeLeaveCriticalRegion();
691
692 return STATUS_SUCCESS;
693 }
694
695 KeLeaveCriticalRegion();
696
697 return STATUS_INVALID_HANDLE;
698 }
699
700
701 /*
702 * FUNCTION: Increments the reference count for an object and returns a
703 * pointer to its body
704 * ARGUMENTS:
705 * Handle = Handle for the object
706 * DesiredAccess = Desired access to the object
707 * ObjectType
708 * AccessMode
709 * Object (OUT) = Points to the object body on return
710 * HandleInformation (OUT) = Contains information about the handle
711 * on return
712 * RETURNS: Status
713 *
714 * @implemented
715 */
716 NTSTATUS STDCALL
717 ObReferenceObjectByHandle(HANDLE Handle,
718 ACCESS_MASK DesiredAccess,
719 POBJECT_TYPE ObjectType,
720 KPROCESSOR_MODE AccessMode,
721 PVOID* Object,
722 POBJECT_HANDLE_INFORMATION HandleInformation)
723 {
724 PHANDLE_TABLE_ENTRY HandleEntry;
725 POBJECT_HEADER ObjectHeader;
726 PHANDLE_TABLE HandleTable;
727 PVOID ObjectBody;
728 ACCESS_MASK GrantedAccess;
729 ULONG Attributes;
730
731 PAGED_CODE();
732
733 DPRINT("ObReferenceObjectByHandle(Handle %x, DesiredAccess %x, "
734 "ObjectType %x, AccessMode %d, Object %x)\n",Handle,DesiredAccess,
735 ObjectType,AccessMode,Object);
736
737 if (Handle == NULL)
738 {
739 return STATUS_INVALID_HANDLE;
740 }
741 /*
742 * Handle special handle names
743 */
744 if (Handle == NtCurrentProcess() &&
745 (ObjectType == PsProcessType || ObjectType == NULL))
746 {
747 PEPROCESS CurrentProcess = PsGetCurrentProcess();
748
749 ObReferenceObject(CurrentProcess);
750
751 if (HandleInformation != NULL)
752 {
753 HandleInformation->HandleAttributes = 0;
754 HandleInformation->GrantedAccess = PROCESS_ALL_ACCESS;
755 }
756
757 *Object = CurrentProcess;
758 DPRINT("Referencing current process %x\n", CurrentProcess);
759 return STATUS_SUCCESS;
760 }
761 else if (Handle == NtCurrentProcess())
762 {
763 CHECKPOINT;
764 return(STATUS_OBJECT_TYPE_MISMATCH);
765 }
766
767 if (Handle == NtCurrentThread() &&
768 (ObjectType == PsThreadType || ObjectType == NULL))
769 {
770 PETHREAD CurrentThread = PsGetCurrentThread();
771
772 ObReferenceObject(CurrentThread);
773
774 if (HandleInformation != NULL)
775 {
776 HandleInformation->HandleAttributes = 0;
777 HandleInformation->GrantedAccess = THREAD_ALL_ACCESS;
778 }
779
780 *Object = CurrentThread;
781 CHECKPOINT;
782 return STATUS_SUCCESS;
783 }
784 else if (Handle == NtCurrentThread())
785 {
786 CHECKPOINT;
787 return(STATUS_OBJECT_TYPE_MISMATCH);
788 }
789
790 /* desire as much access rights as possible */
791 if (DesiredAccess & MAXIMUM_ALLOWED)
792 {
793 DesiredAccess &= ~MAXIMUM_ALLOWED;
794 DesiredAccess |= GENERIC_ALL;
795 }
796
797 if(ObIsKernelHandle(Handle, AccessMode))
798 {
799 HandleTable = ObpKernelHandleTable;
800 Handle = ObKernelHandleToHandle(Handle);
801 }
802 else
803 {
804 HandleTable = PsGetCurrentProcess()->ObjectTable;
805 }
806
807 KeEnterCriticalRegion();
808
809 HandleEntry = ExMapHandleToPointer(HandleTable,
810 Handle);
811 if (HandleEntry == NULL)
812 {
813 KeLeaveCriticalRegion();
814 DPRINT("ExMapHandleToPointer() failed for handle 0x%x\n", Handle);
815 return(STATUS_INVALID_HANDLE);
816 }
817
818 ObjectHeader = EX_HTE_TO_HDR(HandleEntry);
819 ObjectBody = &ObjectHeader->Body;
820
821 DPRINT("locked1: ObjectHeader: 0x%x [HT:0x%x]\n", ObjectHeader, HandleTable);
822
823 if (ObjectType != NULL && ObjectType != ObjectHeader->Type)
824 {
825 DPRINT("ObjectType mismatch: %wZ vs %wZ (handle 0x%x)\n", &ObjectType->Name, ObjectHeader->Type ? &ObjectHeader->Type->Name : NULL, Handle);
826
827 ExUnlockHandleTableEntry(HandleTable,
828 HandleEntry);
829
830 KeLeaveCriticalRegion();
831
832 return(STATUS_OBJECT_TYPE_MISMATCH);
833 }
834
835 /* map the generic access masks if the caller asks for generic access */
836 if (DesiredAccess & GENERIC_ANY)
837 {
838 RtlMapGenericMask(&DesiredAccess,
839 &BODY_TO_HEADER(ObjectBody)->Type->TypeInfo.GenericMapping);
840 }
841
842 GrantedAccess = HandleEntry->u2.GrantedAccess;
843
844 /* Unless running as KernelMode, deny access if caller desires more access
845 rights than the handle can grant */
846 if(AccessMode != KernelMode && (~GrantedAccess & DesiredAccess))
847 {
848 ExUnlockHandleTableEntry(HandleTable,
849 HandleEntry);
850
851 KeLeaveCriticalRegion();
852
853 DPRINT1("GrantedAccess: 0x%x, ~GrantedAccess: 0x%x, DesiredAccess: 0x%x, denied: 0x%x\n", GrantedAccess, ~GrantedAccess, DesiredAccess, ~GrantedAccess & DesiredAccess);
854
855 return(STATUS_ACCESS_DENIED);
856 }
857
858 ObReferenceObject(ObjectBody);
859
860 Attributes = HandleEntry->u1.ObAttributes & (EX_HANDLE_ENTRY_PROTECTFROMCLOSE |
861 EX_HANDLE_ENTRY_INHERITABLE |
862 EX_HANDLE_ENTRY_AUDITONCLOSE);
863
864 ExUnlockHandleTableEntry(HandleTable,
865 HandleEntry);
866
867 KeLeaveCriticalRegion();
868
869 if (HandleInformation != NULL)
870 {
871 HandleInformation->HandleAttributes = Attributes;
872 HandleInformation->GrantedAccess = GrantedAccess;
873 }
874
875 *Object = ObjectBody;
876
877 return(STATUS_SUCCESS);
878 }
879
880
881 /**********************************************************************
882 * NAME EXPORTED
883 * NtClose
884 *
885 * DESCRIPTION
886 * Closes a handle reference to an object.
887 *
888 * ARGUMENTS
889 * Handle
890 * Handle to close.
891 *
892 * RETURN VALUE
893 * Status.
894 *
895 * @implemented
896 */
897 NTSTATUS STDCALL
898 NtClose(IN HANDLE Handle)
899 {
900 PHANDLE_TABLE HandleTable;
901 NTSTATUS Status;
902
903 PAGED_CODE();
904
905 if(ObIsKernelHandle(Handle, ExGetPreviousMode()))
906 {
907 HandleTable = ObpKernelHandleTable;
908 Handle = ObKernelHandleToHandle(Handle);
909 }
910 else
911 {
912 HandleTable = PsGetCurrentProcess()->ObjectTable;
913 }
914
915 Status = ObpDeleteHandle(HandleTable,
916 Handle);
917 if (!NT_SUCCESS(Status))
918 {
919 if((ExGetPreviousMode() != KernelMode) &&
920 (PsGetCurrentProcess()->ExceptionPort))
921 {
922 KeRaiseUserException(Status);
923 }
924 return Status;
925 }
926
927 return(STATUS_SUCCESS);
928 }
929
930
931 /*
932 * @implemented
933 */
934 NTSTATUS
935 STDCALL
936 ObInsertObject(IN PVOID Object,
937 IN PACCESS_STATE PassedAccessState OPTIONAL,
938 IN ACCESS_MASK DesiredAccess,
939 IN ULONG AdditionalReferences,
940 OUT PVOID* ReferencedObject OPTIONAL,
941 OUT PHANDLE Handle)
942 {
943 POBJECT_CREATE_INFORMATION ObjectCreateInfo;
944 POBJECT_HEADER Header;
945 POBJECT_HEADER_NAME_INFO ObjectNameInfo;
946 PVOID FoundObject = NULL;
947 POBJECT_HEADER FoundHeader = NULL;
948 NTSTATUS Status = STATUS_SUCCESS;
949 UNICODE_STRING RemainingPath;
950 BOOLEAN ObjectAttached = FALSE;
951 PSECURITY_DESCRIPTOR NewSecurityDescriptor = NULL;
952 SECURITY_SUBJECT_CONTEXT SubjectContext;
953
954 PAGED_CODE();
955
956 /* Get the Header and Create Info */
957 DPRINT("ObInsertObject: %x\n", Object);
958 Header = BODY_TO_HEADER(Object);
959 ObjectCreateInfo = Header->ObjectCreateInfo;
960 ObjectNameInfo = HEADER_TO_OBJECT_NAME(Header);
961
962 /* First try to find the Object */
963 if (ObjectNameInfo && ObjectNameInfo->Name.Buffer)
964 {
965 DPRINT("Object has a name. Trying to find it: %wZ.\n", &ObjectNameInfo->Name);
966 Status = ObFindObject(ObjectCreateInfo,
967 &ObjectNameInfo->Name,
968 &FoundObject,
969 &RemainingPath,
970 NULL);
971 DPRINT("FoundObject: %x, Path: %wZ\n", FoundObject, &RemainingPath);
972 if (!NT_SUCCESS(Status))
973 {
974 DPRINT1("ObFindObject() failed! (Status 0x%x)\n", Status);
975 return Status;
976 }
977
978 if (FoundObject)
979 {
980 DPRINT("Getting header: %x\n", FoundObject);
981 FoundHeader = BODY_TO_HEADER(FoundObject);
982 }
983
984 if (FoundHeader && RemainingPath.Buffer == NULL)
985 {
986 DPRINT("Object exists\n");
987 ObDereferenceObject(FoundObject);
988 return STATUS_OBJECT_NAME_COLLISION;
989 }
990 }
991 else
992 {
993 DPRINT("No name, empty remaining path\n");
994 RtlInitUnicodeString(&RemainingPath, NULL);
995 }
996
997 if (FoundHeader && FoundHeader->Type == ObDirectoryType &&
998 RemainingPath.Buffer)
999 {
1000 /* The name was changed so let's update it */
1001 /* FIXME: TEMPORARY HACK This will go in ObFindObject in the next commit */
1002 PVOID NewName;
1003 PWSTR BufferPos = RemainingPath.Buffer;
1004 ULONG Delta = 0;
1005
1006 ObpAddEntryDirectory(FoundObject, Header, NULL);
1007 ObjectAttached = TRUE;
1008
1009 ObjectNameInfo = HEADER_TO_OBJECT_NAME(Header);
1010
1011 if (BufferPos[0] == L'\\')
1012 {
1013 BufferPos++;
1014 Delta = sizeof(WCHAR);
1015 }
1016 NewName = ExAllocatePool(NonPagedPool, RemainingPath.MaximumLength - Delta);
1017 RtlMoveMemory(NewName, BufferPos, RemainingPath.MaximumLength - Delta);
1018 if (ObjectNameInfo->Name.Buffer) ExFreePool(ObjectNameInfo->Name.Buffer);
1019 ObjectNameInfo->Name.Buffer = NewName;
1020 ObjectNameInfo->Name.Length = RemainingPath.Length - Delta;
1021 ObjectNameInfo->Name.MaximumLength = RemainingPath.MaximumLength - Delta;
1022 DPRINT("Name: %S\n", ObjectNameInfo->Name.Buffer);
1023 }
1024
1025 if ((Header->Type == IoFileObjectType) ||
1026 (Header->Type == ExDesktopObjectType) ||
1027 (Header->Type->TypeInfo.OpenProcedure != NULL))
1028 {
1029 DPRINT("About to call Open Routine\n");
1030 if (Header->Type == IoFileObjectType)
1031 {
1032 /* TEMPORARY HACK. DO NOT TOUCH -- Alex */
1033 DPRINT("Calling IopCreateFile: %x\n", FoundObject);
1034 Status = IopCreateFile(&Header->Body,
1035 FoundObject,
1036 RemainingPath.Buffer,
1037 ObjectCreateInfo);
1038 DPRINT("Called IopCreateFile: %x\n", Status);
1039
1040 }
1041 else if (Header->Type == ExDesktopObjectType)
1042 {
1043 /* TEMPORARY HACK. DO NOT TOUCH -- Alex */
1044 DPRINT("Calling ExpDesktopCreate\n");
1045 Status = ExpDesktopCreate(&Header->Body,
1046 FoundObject,
1047 RemainingPath.Buffer,
1048 ObjectCreateInfo);
1049 }
1050 else if (Header->Type->TypeInfo.OpenProcedure != NULL)
1051 {
1052 DPRINT("Calling %x\n", Header->Type->TypeInfo.OpenProcedure);
1053 Status = Header->Type->TypeInfo.OpenProcedure(ObCreateHandle,
1054 &Header->Body,
1055 NULL,
1056 0,
1057 0);
1058 }
1059
1060 if (!NT_SUCCESS(Status))
1061 {
1062 DPRINT("Create Failed\n");
1063 if (ObjectAttached == TRUE)
1064 {
1065 ObpRemoveEntryDirectory(Header);
1066 }
1067 if (FoundObject)
1068 {
1069 ObDereferenceObject(FoundObject);
1070 }
1071 RtlFreeUnicodeString(&RemainingPath);
1072 return Status;
1073 }
1074 }
1075
1076 RtlFreeUnicodeString(&RemainingPath);
1077
1078 DPRINT("Security Assignment in progress\n");
1079 SeCaptureSubjectContext(&SubjectContext);
1080
1081 /* Build the new security descriptor */
1082 Status = SeAssignSecurity((FoundHeader != NULL) ? FoundHeader->SecurityDescriptor : NULL,
1083 (ObjectCreateInfo != NULL) ? ObjectCreateInfo->SecurityDescriptor : NULL,
1084 &NewSecurityDescriptor,
1085 (Header->Type == ObDirectoryType),
1086 &SubjectContext,
1087 &Header->Type->TypeInfo.GenericMapping,
1088 PagedPool);
1089
1090 if (NT_SUCCESS(Status))
1091 {
1092 DPRINT("NewSecurityDescriptor %p\n", NewSecurityDescriptor);
1093
1094 if (Header->Type->TypeInfo.SecurityProcedure != NULL)
1095 {
1096 /* Call the security method */
1097 Status = Header->Type->TypeInfo.SecurityProcedure(&Header->Body,
1098 AssignSecurityDescriptor,
1099 0,
1100 NewSecurityDescriptor,
1101 NULL,
1102 NULL,
1103 NonPagedPool,
1104 NULL);
1105 }
1106 else
1107 {
1108 /* Assign the security descriptor to the object header */
1109 Status = ObpAddSecurityDescriptor(NewSecurityDescriptor,
1110 &Header->SecurityDescriptor);
1111 DPRINT("Object security descriptor %p\n", Header->SecurityDescriptor);
1112 }
1113
1114 /* Release the new security descriptor */
1115 SeDeassignSecurity(&NewSecurityDescriptor);
1116 }
1117
1118 DPRINT("Security Complete\n");
1119 SeReleaseSubjectContext(&SubjectContext);
1120
1121 /* Create the Handle */
1122 /* HACKHACK: Because of ROS's incorrect startup, this can be called
1123 * without a valid Process until I finalize the startup patch,
1124 * so don't create a handle if this is the case. We also don't create
1125 * a handle if Handle is NULL when the Registry Code calls it, because
1126 * the registry code totally bastardizes the Ob and needs to be fixed
1127 */
1128 DPRINT("Creating handle\n");
1129 if (Handle != NULL)
1130 {
1131 Status = ObpCreateHandle(PsGetCurrentProcess(),
1132 &Header->Body,
1133 DesiredAccess,
1134 ObjectCreateInfo->Attributes & OBJ_INHERIT,
1135 Handle);
1136 DPRINT("handle Created: %d. refcount. handlecount %d %d\n",
1137 *Handle, Header->PointerCount, Header->HandleCount);
1138 }
1139
1140 /* We can delete the Create Info now */
1141 Header->ObjectCreateInfo = NULL;
1142 ObpReleaseCapturedAttributes(ObjectCreateInfo);
1143 ExFreePool(ObjectCreateInfo);
1144
1145 DPRINT("Status %x\n", Status);
1146 return Status;
1147 }
1148
1149
1150 ULONG
1151 NTAPI
1152 ObpGetHandleCountByHandleTable(PHANDLE_TABLE HandleTable)
1153 {
1154 return HandleTable->HandleCount;
1155 }
1156
1157 /*
1158 * FUNCTION: Searches the handle table of a specified process whether it contains a
1159 * valid handle to the Object we're looking for. If not, it'll create one.
1160 *
1161 * NOTES:
1162 * The parameters of this function is basically a mixture of some of the parameters
1163 * of ObReferenceObjectByHandle() and ObReferenceObjectByPointer(). A little thinking
1164 * about what this function does (by it's name) makes clear what parameters it requires.
1165 * For example the AccessMode parameter of ObReferenceObjectByHandle/Pointer() is not
1166 * required at all as it only has influence on the object security. This function doesn't
1167 * want to get access to an object, it just looks for a valid handle and if it can't find
1168 * one, it'll just create one. It wouldn't make sense to check for security again as the
1169 * caller already has a pointer to the object.
1170 *
1171 * A test on an XP machine shows that this prototype appears to be correct.
1172 *
1173 * ARGUMENTS:
1174 * Process = This parameter simply describes in which handle table we're looking
1175 * for a handle to the object.
1176 * Object = The object pointer that we're looking for
1177 * ObjectType = Just a sanity check as ObReferenceObjectByHandle() and
1178 * ObReferenceObjectByPointer() provides.
1179 * HandleInformation = This one has to be the opposite meaning of the usage in
1180 * ObReferenceObjectByHandle(). If we actually found a valid
1181 * handle in the table, we need to check against the information
1182 * provided so we make sure this handle has all access rights
1183 * (and attributes?!) we need. If they don't match, we can't
1184 * use this handle and keep looking because the caller is likely
1185 * to depend on these access rights.
1186 * HandleReturn = The last parameter is the same as in ObCreateHandle(). If we could
1187 * find a suitable handle in the handle table, return this handle, if
1188 * not, we'll just create one using ObCreateHandle() with all access
1189 * rights the caller needs.
1190 *
1191 * RETURNS: Status
1192 *
1193 * @unimplemented
1194 */
1195 NTSTATUS STDCALL
1196 ObFindHandleForObject(IN PEPROCESS Process,
1197 IN PVOID Object,
1198 IN POBJECT_TYPE ObjectType,
1199 IN POBJECT_HANDLE_INFORMATION HandleInformation,
1200 OUT PHANDLE HandleReturn)
1201 {
1202 DPRINT("ObFindHandleForObject is unimplemented!\n");
1203 return STATUS_UNSUCCESSFUL;
1204 }
1205
1206 VOID
1207 ObpGetNextHandleByProcessCount(PSYSTEM_HANDLE_TABLE_ENTRY_INFO pshi,
1208 PEPROCESS Process,
1209 int Count)
1210 {
1211 ULONG P;
1212 // KIRQL oldIrql;
1213
1214 // pshi->HandleValue;
1215
1216 /*
1217 This will never work with ROS! M$, I guess uses 0 -> 65535.
1218 Ros uses 0 -> 4294967295!
1219 */
1220
1221 P = (ULONG) Process->UniqueProcessId;
1222 pshi->UniqueProcessId = (USHORT) P;
1223
1224 // KeAcquireSpinLock( &Process->HandleTable.ListLock, &oldIrql );
1225
1226 // pshi->GrantedAccess;
1227 // pshi->Object;
1228 // pshi->TypeIndex;
1229 // pshi->HandleAttributes;
1230
1231 // KeReleaseSpinLock( &Process->HandleTable.ListLock, oldIrql );
1232
1233 return;
1234 }
1235
1236
1237
1238 /* EOF */