reactos/ntoskrnl/ob/namespc.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:      See COPYING in the top level directory
   4  * PROJECT:        ReactOS kernel
   5  * FILE:           ntoskrnl/ob/namespc.c
   6  * PURPOSE:        Manages the system namespace
   7  *
   8  * PROGRAMMERS:    David Welch (welch@mcmail.com)
   9  */
  10
  11 /* INCLUDES ***************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <internal/debug.h>
  16
  17 #if defined (ALLOC_PRAGMA)
  18 #pragma alloc_text(INIT, ObInit)
  19 #endif
  20
  21
  22 extern ULONG NtGlobalFlag;
  23
  24 /* GLOBALS ****************************************************************/
  25
  26 POBJECT_TYPE ObDirectoryType = NULL;
  27 POBJECT_TYPE ObTypeObjectType = NULL;
  28
  29 PDIRECTORY_OBJECT NameSpaceRoot = NULL;
  30 PDIRECTORY_OBJECT ObpTypeDirectoryObject = NULL;
  31  /* FIXME: Move this somewhere else once devicemap support is in */
  32 PDEVICE_MAP ObSystemDeviceMap = NULL;
  33 KEVENT ObpDefaultObject;
  34
  35 static GENERIC_MAPPING ObpDirectoryMapping = {
  36         STANDARD_RIGHTS_READ|DIRECTORY_QUERY|DIRECTORY_TRAVERSE,
  37         STANDARD_RIGHTS_WRITE|DIRECTORY_CREATE_OBJECT|DIRECTORY_CREATE_SUBDIRECTORY,
  38         STANDARD_RIGHTS_EXECUTE|DIRECTORY_QUERY|DIRECTORY_TRAVERSE,
  39         DIRECTORY_ALL_ACCESS};
  40
  41 static GENERIC_MAPPING ObpTypeMapping = {
  42         STANDARD_RIGHTS_READ,
  43         STANDARD_RIGHTS_WRITE,
  44         STANDARD_RIGHTS_EXECUTE,
  45         0x000F0001};
  46
  47 NTSTATUS
  48 STDCALL
  49 ObpAllocateObject(POBJECT_CREATE_INFORMATION ObjectCreateInfo,
  50                   PUNICODE_STRING ObjectName,
  51                   POBJECT_TYPE ObjectType,
  52                   ULONG ObjectSize,
  53                   POBJECT_HEADER *ObjectHeader);
  54
  55 /* FUNCTIONS **************************************************************/
  56
  57 /*
  58  * @implemented
  59  */
  60 NTSTATUS STDCALL
  61 ObReferenceObjectByName(PUNICODE_STRING ObjectPath,
  62                         ULONG Attributes,
  63                         PACCESS_STATE PassedAccessState,
  64                         ACCESS_MASK DesiredAccess,
  65                         POBJECT_TYPE ObjectType,
  66                         KPROCESSOR_MODE AccessMode,
  67                         PVOID ParseContext,
  68                         PVOID* ObjectPtr)
  69 {
  70    PVOID Object = NULL;
  71    UNICODE_STRING RemainingPath;
  72    UNICODE_STRING ObjectName;
  73    OBJECT_CREATE_INFORMATION ObjectCreateInfo;
  74    NTSTATUS Status;
  75
  76    PAGED_CODE();
  77
  78    /* Capture the name */
  79    DPRINT("Capturing Name\n");
  80    Status = ObpCaptureObjectName(&ObjectName, ObjectPath, AccessMode);
  81    if (!NT_SUCCESS(Status))
  82      {
  83         DPRINT("ObpCaptureObjectName() failed (Status %lx)\n", Status);
  84         return Status;
  85      }
  86
  87    /*
  88     * Create a fake ObjectCreateInfo structure. Note that my upcoming
  89     * ObFindObject refactoring will remove the need for this hack.
  90     */
  91    ObjectCreateInfo.RootDirectory = NULL;
  92    ObjectCreateInfo.Attributes = Attributes;
  93
  94    Status = ObFindObject(&ObjectCreateInfo,
  95                          &ObjectName,
  96                          &Object,
  97                          &RemainingPath,
  98                          ObjectType);
  99
 100    if (ObjectName.Buffer) ExFreePool(ObjectName.Buffer);
 101
 102    if (!NT_SUCCESS(Status))
 103      {
 104         return(Status);
 105      }
 106    DPRINT("RemainingPath.Buffer '%S' Object %p\n", RemainingPath.Buffer, Object);
 107
 108    if (RemainingPath.Buffer != NULL || Object == NULL)
 109      {
 110         DPRINT("Object %p\n", Object);
 111         *ObjectPtr = NULL;
 112         RtlFreeUnicodeString (&RemainingPath);
 113         return(STATUS_OBJECT_NAME_NOT_FOUND);
 114      }
 115    *ObjectPtr = Object;
 116    RtlFreeUnicodeString (&RemainingPath);
 117    return(STATUS_SUCCESS);
 118 }
 119
 120
 121 /**********************************************************************
 122  * NAME                                                 EXPORTED
 123  *      ObOpenObjectByName
 124  *
 125  * DESCRIPTION
 126  *      Obtain a handle to an existing object.
 127  *
 128  * ARGUMENTS
 129  *      ObjectAttributes
 130  *              ...
 131  *      ObjectType
 132  *              ...
 133  *      ParseContext
 134  *              ...
 135  *      AccessMode
 136  *              ...
 137  *      DesiredAccess
 138  *              ...
 139  *      PassedAccessState
 140  *              ...
 141  *      Handle
 142  *              Handle to close.
 143  *
 144  * RETURN VALUE
 145  *      Status.
 146  *
 147  * @implemented
 148  */
 149 NTSTATUS STDCALL
 150 ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
 151                    IN POBJECT_TYPE ObjectType,
 152                    IN OUT PVOID ParseContext,
 153                    IN KPROCESSOR_MODE AccessMode,
 154                    IN ACCESS_MASK DesiredAccess,
 155                    IN PACCESS_STATE PassedAccessState,
 156                    OUT PHANDLE Handle)
 157 {
 158    UNICODE_STRING RemainingPath;
 159    PVOID Object = NULL;
 160    UNICODE_STRING ObjectName;
 161    OBJECT_CREATE_INFORMATION ObjectCreateInfo;
 162    NTSTATUS Status;
 163
 164    PAGED_CODE();
 165
 166    DPRINT("ObOpenObjectByName(...)\n");
 167
 168     /* Capture all the info */
 169     DPRINT("Capturing Create Info\n");
 170     Status = ObpCaptureObjectAttributes(ObjectAttributes,
 171                                         AccessMode,
 172                                         ObjectType,
 173                                         &ObjectCreateInfo,
 174                                         &ObjectName);
 175    if (!NT_SUCCESS(Status))
 176      {
 177         DPRINT("ObpCaptureObjectAttributes() failed (Status %lx)\n", Status);
 178         return Status;
 179      }
 180
 181    Status = ObFindObject(&ObjectCreateInfo,
 182                          &ObjectName,
 183                          &Object,
 184                          &RemainingPath,
 185                          ObjectType);
 186    ObpReleaseCapturedAttributes(&ObjectCreateInfo);
 187    if (ObjectName.Buffer) ExFreePool(ObjectName.Buffer);
 188    if (!NT_SUCCESS(Status))
 189      {
 190         DPRINT("ObFindObject() failed (Status %lx)\n", Status);
 191         return Status;
 192      }
 193
 194    DPRINT("OBject: %x, Remaining Path: %wZ\n", Object, &RemainingPath);
 195    if (Object == NULL)
 196      {
 197        RtlFreeUnicodeString(&RemainingPath);
 198        return STATUS_UNSUCCESSFUL;
 199      }
 200    if (RemainingPath.Buffer != NULL)
 201    {
 202       if (wcschr(RemainingPath.Buffer + 1, L'\\') == NULL)
 203          Status = STATUS_OBJECT_NAME_NOT_FOUND;
 204       else
 205          Status =STATUS_OBJECT_PATH_NOT_FOUND;
 206       RtlFreeUnicodeString(&RemainingPath);
 207       ObDereferenceObject(Object);
 208       return Status;
 209    }
 210
 211    Status = ObpCreateHandle(PsGetCurrentProcess(),
 212                            Object,
 213                            DesiredAccess,
 214                            FALSE,
 215                            Handle);
 216
 217    ObDereferenceObject(Object);
 218    RtlFreeUnicodeString(&RemainingPath);
 219
 220    return Status;
 221 }
 222
 223 VOID
 224 STDCALL
 225 ObQueryDeviceMapInformation(PEPROCESS Process,
 226                             PPROCESS_DEVICEMAP_INFORMATION DeviceMapInfo)
 227 {
 228         //KIRQL OldIrql ;
 229
 230         /*
 231          * FIXME: This is an ugly hack for now, to always return the System Device Map
 232          * instead of returning the Process Device Map. Not important yet since we don't use it
 233          */
 234
 235          /* FIXME: Acquire the DeviceMap Spinlock */
 236          // KeAcquireSpinLock(DeviceMap->Lock, &OldIrql);
 237
 238          /* Make a copy */
 239          DeviceMapInfo->Query.DriveMap = ObSystemDeviceMap->DriveMap;
 240          RtlMoveMemory(DeviceMapInfo->Query.DriveType, ObSystemDeviceMap->DriveType, sizeof(ObSystemDeviceMap->DriveType));
 241
 242          /* FIXME: Release the DeviceMap Spinlock */
 243          // KeReleasepinLock(DeviceMap->Lock, OldIrql);
 244 }
 245
 246 VOID
 247 NTAPI
 248 ObpAddEntryDirectory(PDIRECTORY_OBJECT Parent,
 249                      POBJECT_HEADER Header,
 250                      PWSTR Name)
 251 /*
 252  * FUNCTION: Add an entry to a namespace directory
 253  * ARGUMENTS:
 254  *         Parent = directory to add in
 255  *         Header = Header of the object to add the entry for
 256  *         Name = Name to give the entry
 257  */
 258 {
 259   KIRQL oldlvl;
 260
 261   ASSERT(HEADER_TO_OBJECT_NAME(Header));
 262   HEADER_TO_OBJECT_NAME(Header)->Directory = Parent;
 263
 264   KeAcquireSpinLock(&Parent->Lock, &oldlvl);
 265   InsertTailList(&Parent->head, &Header->Entry);
 266   KeReleaseSpinLock(&Parent->Lock, oldlvl);
 267 }
 268
 269
 270 VOID
 271 NTAPI
 272 ObpRemoveEntryDirectory(POBJECT_HEADER Header)
 273 /*
 274  * FUNCTION: Remove an entry from a namespace directory
 275  * ARGUMENTS:
 276  *         Header = Header of the object to remove
 277  */
 278 {
 279   KIRQL oldlvl;
 280
 281   DPRINT("ObpRemoveEntryDirectory(Header %x)\n",Header);
 282
 283   KeAcquireSpinLock(&(HEADER_TO_OBJECT_NAME(Header)->Directory->Lock),&oldlvl);
 284   if (Header->Entry.Flink && Header->Entry.Blink)
 285   {
 286     RemoveEntryList(&(Header->Entry));
 287     Header->Entry.Flink = Header->Entry.Blink = NULL;
 288   }
 289   KeReleaseSpinLock(&(HEADER_TO_OBJECT_NAME(Header)->Directory->Lock),oldlvl);
 290 }
 291
 292 NTSTATUS
 293 STDCALL
 294 ObpCreateDirectory(OB_OPEN_REASON Reason,
 295                    PVOID ObjectBody,
 296                    PEPROCESS Process,
 297                    ULONG HandleCount,
 298                    ACCESS_MASK GrantedAccess)
 299 {
 300     PDIRECTORY_OBJECT Directory = ObjectBody;
 301
 302     if (Reason == ObCreateHandle)
 303     {
 304         InitializeListHead(&Directory->head);
 305         KeInitializeSpinLock(&Directory->Lock);
 306     }
 307
 308     return STATUS_SUCCESS;
 309 }
 310
 311 PVOID
 312 ObpFindEntryDirectory(PDIRECTORY_OBJECT DirectoryObject,
 313                       PWSTR Name,
 314                       ULONG Attributes)
 315 {
 316    PLIST_ENTRY current = DirectoryObject->head.Flink;
 317    POBJECT_HEADER current_obj;
 318
 319    DPRINT("ObFindEntryDirectory(dir %x, name %S)\n",DirectoryObject, Name);
 320
 321    if (Name[0]==0)
 322      {
 323         return(DirectoryObject);
 324      }
 325    if (Name[0]=='.' && Name[1]==0)
 326      {
 327         return(DirectoryObject);
 328      }
 329    if (Name[0]=='.' && Name[1]=='.' && Name[2]==0)
 330      {
 331         return(HEADER_TO_OBJECT_NAME(BODY_TO_HEADER(DirectoryObject))->Directory);
 332      }
 333    while (current!=(&(DirectoryObject->head)))
 334      {
 335         current_obj = CONTAINING_RECORD(current,OBJECT_HEADER,Entry);
 336         DPRINT("  Scanning: %S for: %S\n",HEADER_TO_OBJECT_NAME(current_obj)->Name.Buffer, Name);
 337         if (Attributes & OBJ_CASE_INSENSITIVE)
 338           {
 339              if (_wcsicmp(HEADER_TO_OBJECT_NAME(current_obj)->Name.Buffer, Name)==0)
 340                {
 341                   DPRINT("Found it %x\n",&current_obj->Body);
 342                   return(&current_obj->Body);
 343                }
 344           }
 345         else
 346           {
 347              if ( wcscmp(HEADER_TO_OBJECT_NAME(current_obj)->Name.Buffer, Name)==0)
 348                {
 349                   DPRINT("Found it %x\n",&current_obj->Body);
 350                   return(&current_obj->Body);
 351                }
 352           }
 353         current = current->Flink;
 354      }
 355    DPRINT("    Not Found: %s() = NULL\n",__FUNCTION__);
 356    return(NULL);
 357 }
 358
 359
 360 NTSTATUS STDCALL
 361 ObpParseDirectory(PVOID Object,
 362                   PVOID * NextObject,
 363                   PUNICODE_STRING FullPath,
 364                   PWSTR * Path,
 365                   ULONG Attributes)
 366 {
 367   PWSTR Start;
 368   PWSTR End;
 369   PVOID FoundObject;
 370   KIRQL oldlvl;
 371
 372   DPRINT("ObpParseDirectory(Object %x, Path %x, *Path %S)\n",
 373          Object,Path,*Path);
 374
 375   *NextObject = NULL;
 376
 377   if ((*Path) == NULL)
 378     {
 379       return STATUS_UNSUCCESSFUL;
 380     }
 381
 382   Start = *Path;
 383   if (*Start == L'\\')
 384     Start++;
 385
 386   End = wcschr(Start, L'\\');
 387   if (End != NULL)
 388     {
 389       *End = 0;
 390     }
 391
 392   KeAcquireSpinLock(&(((PDIRECTORY_OBJECT)Object)->Lock), &oldlvl);
 393   FoundObject = ObpFindEntryDirectory(Object, Start, Attributes);
 394   if (FoundObject == NULL)
 395     {
 396       KeReleaseSpinLock(&(((PDIRECTORY_OBJECT)Object)->Lock), oldlvl);
 397       if (End != NULL)
 398         {
 399           *End = L'\\';
 400         }
 401       return STATUS_UNSUCCESSFUL;
 402     }
 403
 404   ObReferenceObjectByPointer(FoundObject,
 405                              STANDARD_RIGHTS_REQUIRED,
 406                              NULL,
 407                              UserMode);
 408   KeReleaseSpinLock(&(((PDIRECTORY_OBJECT)Object)->Lock), oldlvl);
 409   if (End != NULL)
 410     {
 411       *End = L'\\';
 412       *Path = End;
 413     }
 414   else
 415     {
 416       *Path = NULL;
 417     }
 418
 419   *NextObject = FoundObject;
 420
 421   return STATUS_SUCCESS;
 422 }
 423
 424 VOID
 425 INIT_FUNCTION
 426 ObInit(VOID)
 427 {
 428     OBJECT_ATTRIBUTES ObjectAttributes;
 429     UNICODE_STRING Name;
 430     SECURITY_DESCRIPTOR SecurityDescriptor;
 431     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
 432
 433     /* Initialize the security descriptor cache */
 434     ObpInitSdCache();
 435
 436     /* Initialize the Default Event */
 437     KeInitializeEvent(&ObpDefaultObject, NotificationEvent, TRUE );
 438
 439     /* Create the Type Type */
 440     DPRINT("Creating Type Type\n");
 441     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
 442     RtlInitUnicodeString(&Name, L"Type");
 443     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
 444     ObjectTypeInitializer.ValidAccessMask = OBJECT_TYPE_ALL_ACCESS;
 445     ObjectTypeInitializer.UseDefaultObject = TRUE;
 446     ObjectTypeInitializer.MaintainTypeList = TRUE;
 447     ObjectTypeInitializer.PoolType = NonPagedPool;
 448     ObjectTypeInitializer.GenericMapping = ObpTypeMapping;
 449     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(OBJECT_TYPE);
 450     ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ObTypeObjectType);
 451
 452     /* Create the Directory Type */
 453     DPRINT("Creating Directory Type\n");
 454     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
 455     RtlInitUnicodeString(&Name, L"Directory");
 456     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
 457     ObjectTypeInitializer.ValidAccessMask = DIRECTORY_ALL_ACCESS;
 458     ObjectTypeInitializer.UseDefaultObject = FALSE;
 459     ObjectTypeInitializer.OpenProcedure = ObpCreateDirectory;
 460     ObjectTypeInitializer.ParseProcedure = ObpParseDirectory;
 461     ObjectTypeInitializer.MaintainTypeList = FALSE;
 462     ObjectTypeInitializer.GenericMapping = ObpDirectoryMapping;
 463     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(DIRECTORY_OBJECT);
 464     ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ObDirectoryType);
 465
 466     /* Create security descriptor */
 467     RtlCreateSecurityDescriptor(&SecurityDescriptor,
 468                                 SECURITY_DESCRIPTOR_REVISION1);
 469     RtlSetOwnerSecurityDescriptor(&SecurityDescriptor,
 470                                   SeAliasAdminsSid,
 471                                   FALSE);
 472     RtlSetGroupSecurityDescriptor(&SecurityDescriptor,
 473                                   SeLocalSystemSid,
 474                                   FALSE);
 475     RtlSetDaclSecurityDescriptor(&SecurityDescriptor,
 476                                  TRUE,
 477                                  SePublicDefaultDacl,
 478                                  FALSE);
 479
 480     /* Create root directory */
 481     DPRINT("Creating Root Directory\n");
 482     InitializeObjectAttributes(&ObjectAttributes,
 483                                NULL,
 484                                OBJ_PERMANENT,
 485                                NULL,
 486                                &SecurityDescriptor);
 487     ObCreateObject(KernelMode,
 488                    ObDirectoryType,
 489                    &ObjectAttributes,
 490                    KernelMode,
 491                    NULL,
 492                    sizeof(DIRECTORY_OBJECT),
 493                    0,
 494                    0,
 495                    (PVOID*)&NameSpaceRoot);
 496     ObInsertObject((PVOID)NameSpaceRoot,
 497                    NULL,
 498                    DIRECTORY_ALL_ACCESS,
 499                    0,
 500                    NULL,
 501                    NULL);
 502
 503     /* Create '\ObjectTypes' directory */
 504     RtlInitUnicodeString(&Name, L"\\ObjectTypes");
 505     InitializeObjectAttributes(&ObjectAttributes,
 506                                &Name,
 507                                OBJ_PERMANENT,
 508                                NULL,
 509                                &SecurityDescriptor);
 510     ObCreateObject(KernelMode,
 511                    ObDirectoryType,
 512                    &ObjectAttributes,
 513                    KernelMode,
 514                    NULL,
 515                    sizeof(DIRECTORY_OBJECT),
 516                    0,
 517                    0,
 518                    (PVOID*)&ObpTypeDirectoryObject);
 519     ObInsertObject((PVOID)ObpTypeDirectoryObject,
 520                    NULL,
 521                    DIRECTORY_ALL_ACCESS,
 522                    0,
 523                    NULL,
 524                    NULL);
 525
 526     /* Insert the two objects we already created but couldn't add */
 527     /* NOTE: Uses TypeList & Creator Info in OB 2.0 */
 528     ObpAddEntryDirectory(ObpTypeDirectoryObject, BODY_TO_HEADER(ObTypeObjectType), NULL);
 529     ObpAddEntryDirectory(ObpTypeDirectoryObject, BODY_TO_HEADER(ObDirectoryType), NULL);
 530
 531     /* Create 'symbolic link' object type */
 532     ObInitSymbolicLinkImplementation();
 533
 534     /* FIXME: Hack Hack! */
 535     ObSystemDeviceMap = ExAllocatePoolWithTag(NonPagedPool, sizeof(*ObSystemDeviceMap), TAG('O', 'b', 'D', 'm'));
 536     RtlZeroMemory(ObSystemDeviceMap, sizeof(*ObSystemDeviceMap));
 537 }
 538
 539 NTSTATUS
 540 STDCALL
 541 ObpCreateTypeObject(POBJECT_TYPE_INITIALIZER ObjectTypeInitializer,
 542                     PUNICODE_STRING TypeName,
 543                     POBJECT_TYPE *ObjectType)
 544 {
 545     POBJECT_HEADER Header;
 546     POBJECT_TYPE LocalObjectType;
 547     ULONG HeaderSize;
 548     NTSTATUS Status;
 549
 550     DPRINT("ObpCreateTypeObject(ObjectType: %wZ)\n", TypeName);
 551
 552     /* Allocate the Object */
 553     Status = ObpAllocateObject(NULL,
 554                                TypeName,
 555                                ObTypeObjectType,
 556                                OBJECT_ALLOC_SIZE(sizeof(OBJECT_TYPE)),
 557                                &Header);
 558     if (!NT_SUCCESS(Status))
 559     {
 560         DPRINT1("ObpAllocateObject failed!\n");
 561         return Status;
 562     }
 563
 564     LocalObjectType = (POBJECT_TYPE)&Header->Body;
 565     DPRINT("Local ObjectType: %p Header: %p \n", LocalObjectType, Header);
 566
 567     /* Check if this is the first Object Type */
 568     if (!ObTypeObjectType)
 569     {
 570         ObTypeObjectType = LocalObjectType;
 571         Header->Type = ObTypeObjectType;
 572         LocalObjectType->Key = TAG('O', 'b', 'j', 'T');
 573     }
 574     else
 575     {
 576         CHAR Tag[4];
 577         Tag[0] = TypeName->Buffer[0];
 578         Tag[1] = TypeName->Buffer[1];
 579         Tag[2] = TypeName->Buffer[2];
 580         Tag[3] = TypeName->Buffer[3];
 581
 582         /* Set Tag */
 583         DPRINT("Convert: %s \n", Tag);
 584         LocalObjectType->Key = *(PULONG)Tag;
 585     }
 586
 587     /* Set it up */
 588     LocalObjectType->TypeInfo = *ObjectTypeInitializer;
 589     LocalObjectType->Name = *TypeName;
 590     LocalObjectType->TypeInfo.PoolType = ObjectTypeInitializer->PoolType;
 591
 592     /* These two flags need to be manually set up */
 593     Header->Flags |= OB_FLAG_KERNEL_MODE | OB_FLAG_PERMANENT;
 594
 595     /* Check if we have to maintain a type list */
 596     if (NtGlobalFlag & FLG_MAINTAIN_OBJECT_TYPELIST)
 597     {
 598         /* Enable support */
 599         LocalObjectType->TypeInfo.MaintainTypeList = TRUE;
 600     }
 601
 602     /* Calculate how much space our header'll take up */
 603     HeaderSize = sizeof(OBJECT_HEADER) + sizeof(OBJECT_HEADER_NAME_INFO) +
 604                  (ObjectTypeInitializer->MaintainHandleCount ?
 605                  sizeof(OBJECT_HEADER_HANDLE_INFO) : 0);
 606
 607     /* Update the Pool Charges */
 608     if (ObjectTypeInitializer->PoolType == NonPagedPool)
 609     {
 610         LocalObjectType->TypeInfo.DefaultNonPagedPoolCharge += HeaderSize;
 611     }
 612     else
 613     {
 614         LocalObjectType->TypeInfo.DefaultPagedPoolCharge += HeaderSize;
 615     }
 616
 617     /* All objects types need a security procedure */
 618     if (!ObjectTypeInitializer->SecurityProcedure)
 619     {
 620         LocalObjectType->TypeInfo.SecurityProcedure = SeDefaultObjectMethod;
 621     }
 622
 623     /* Select the Wait Object */
 624     if (LocalObjectType->TypeInfo.UseDefaultObject)
 625     {
 626         /* Add the SYNCHRONIZE access mask since it's waitable */
 627         LocalObjectType->TypeInfo.ValidAccessMask |= SYNCHRONIZE;
 628
 629         /* Use the "Default Object", a simple event */
 630         LocalObjectType->DefaultObject = &ObpDefaultObject;
 631     }
 632     /* Special system objects get an optimized hack so they can be waited on */
 633     else if (TypeName->Length == 8 && !wcscmp(TypeName->Buffer, L"File"))
 634     {
 635         LocalObjectType->DefaultObject = (PVOID)FIELD_OFFSET(FILE_OBJECT, Event);
 636     }
 637     /* FIXME: When LPC stops sucking, add a hack for Waitable Ports */
 638     else
 639     {
 640         /* No default Object */
 641         LocalObjectType->DefaultObject = NULL;
 642     }
 643
 644     /* Initialize Object Type components */
 645     ExInitializeResourceLite(&LocalObjectType->Mutex);
 646     InitializeListHead(&LocalObjectType->TypeList);
 647
 648     /* Insert it into the Object Directory */
 649     if (ObpTypeDirectoryObject)
 650     {
 651         ObpAddEntryDirectory(ObpTypeDirectoryObject, Header, TypeName->Buffer);
 652         ObReferenceObject(ObpTypeDirectoryObject);
 653     }
 654
 655     *ObjectType = LocalObjectType;
 656     return Status;
 657 }
 658
 659 /* EOF */