reactos/ntoskrnl/ob/dirobj.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:      See COPYING in the top level directory
   4  * PROJECT:        ReactOS kernel
   5  * FILE:           ntoskrnl/ob/dirobj.c
   6  * PURPOSE:        Interface functions to directory object
   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
  18 /* FUNCTIONS **************************************************************/
  19
  20
  21 /**********************************************************************
  22  * NAME                                                 EXPORTED
  23  *      NtOpenDirectoryObject
  24  *
  25  * DESCRIPTION
  26  *      Opens a namespace directory object.
  27  *
  28  * ARGUMENTS
  29  *      DirectoryHandle (OUT)
  30  *              Variable which receives the directory handle.
  31  *
  32  *      DesiredAccess
  33  *              Desired access to the directory.
  34  *
  35  *      ObjectAttributes
  36  *              Structure describing the directory.
  37  *
  38  * RETURN VALUE
  39  *      Status.
  40  *
  41  * NOTES
  42  *      Undocumented.
  43  */
  44 NTSTATUS STDCALL
  45 NtOpenDirectoryObject (OUT PHANDLE DirectoryHandle,
  46                        IN ACCESS_MASK DesiredAccess,
  47                        IN POBJECT_ATTRIBUTES ObjectAttributes)
  48 {
  49    HANDLE hDirectory;
  50    KPROCESSOR_MODE PreviousMode;
  51    NTSTATUS Status = STATUS_SUCCESS;
  52
  53    PAGED_CODE();
  54
  55    PreviousMode = ExGetPreviousMode();
  56
  57    if(PreviousMode != KernelMode)
  58    {
  59      _SEH_TRY
  60      {
  61        ProbeForWriteHandle(DirectoryHandle);
  62      }
  63      _SEH_HANDLE
  64      {
  65        Status = _SEH_GetExceptionCode();
  66      }
  67      _SEH_END;
  68
  69      if(!NT_SUCCESS(Status))
  70      {
  71        DPRINT1("NtOpenDirectoryObject failed, Status: 0x%x\n", Status);
  72        return Status;
  73      }
  74    }
  75
  76    Status = ObOpenObjectByName(ObjectAttributes,
  77                                ObDirectoryType,
  78                                NULL,
  79                                PreviousMode,
  80                                DesiredAccess,
  81                                NULL,
  82                                &hDirectory);
  83    if(NT_SUCCESS(Status))
  84    {
  85      _SEH_TRY
  86      {
  87        *DirectoryHandle = hDirectory;
  88      }
  89      _SEH_HANDLE
  90      {
  91        Status = _SEH_GetExceptionCode();
  92      }
  93      _SEH_END;
  94    }
  95
  96    return Status;
  97 }
  98
  99
 100 /**********************************************************************
 101  * NAME                                                 EXPORTED
 102  *      NtQueryDirectoryObject
 103  *
 104  * DESCRIPTION
 105  *      Reads information from a directory in the system namespace.
 106  *
 107  * ARGUMENTS
 108  *      DirectoryHandle
 109  *              Handle, obtained with NtOpenDirectoryObject(), which
 110  *              must grant DIRECTORY_QUERY access to the directory
 111  *              object.
 112  *
 113  *      Buffer (OUT)
 114  *              Buffer to hold the data read.
 115  *
 116  *      BufferLength
 117  *              Size of the buffer in bytes.
 118  *
 119  *      ReturnSingleEntry
 120  *              When TRUE, only 1 entry is written in DirObjInformation;
 121  *              otherwise as many as will fit in the buffer.
 122  *
 123  *      RestartScan
 124  *              If TRUE start reading at index 0.
 125  *              If FALSE start reading at the index specified
 126  *              by object index *ObjectIndex.
 127  *
 128  *      Context
 129  *              Zero based index into the directory, interpretation
 130  *              depends on RestartScan.
 131  *
 132  *      ReturnLength (OUT)
 133  *              Caller supplied storage for the number of bytes
 134  *              written (or NULL).
 135  *
 136  * RETURN VALUE
 137  *      STATUS_SUCCESS - At least one (possibly more, depending on
 138  *                       parameters and buffer size) dir entry is
 139  *                       returned.
 140  *      STATUS_NO_MORE_ENTRIES - Directory is exhausted
 141  *      STATUS_BUFFER_TOO_SMALL - There isn't enough room in the
 142  *                                buffer to return even 1 entry.
 143  *                                ReturnLength will hold the required
 144  *                                buffer size to return all remaining
 145  *                                dir entries
 146  *      Other - Status code
 147  *
 148  *
 149  * NOTES
 150  *      Although you can iterate over the directory by calling this
 151  *      function multiple times, the directory is unlocked between
 152  *      calls. This means that another thread can change the directory
 153  *      and so iterating doesn't guarantee a consistent picture of the
 154  *      directory. Best thing is to retrieve all directory entries in
 155  *      one call.
 156  */
 157 NTSTATUS STDCALL
 158 NtQueryDirectoryObject (IN HANDLE DirectoryHandle,
 159                         OUT PVOID Buffer,
 160                         IN ULONG BufferLength,
 161                         IN BOOLEAN ReturnSingleEntry,
 162                         IN BOOLEAN RestartScan,
 163                         IN OUT PULONG Context,
 164                         OUT PULONG ReturnLength OPTIONAL)
 165 {
 166   PDIRECTORY_OBJECT Directory;
 167   KPROCESSOR_MODE PreviousMode;
 168   ULONG SkipEntries = 0;
 169   ULONG NextEntry = 0;
 170   ULONG CopyBytes = 0;
 171   NTSTATUS Status = STATUS_SUCCESS;
 172
 173   PAGED_CODE();
 174
 175   PreviousMode = ExGetPreviousMode();
 176
 177   if(PreviousMode != KernelMode)
 178   {
 179     _SEH_TRY
 180     {
 181       /* a test showed that the Buffer pointer just has to be 16 bit aligned,
 182          propably due to the fact that most information that needs to be copied
 183          is unicode strings */
 184       ProbeForWrite(Buffer,
 185                     BufferLength,
 186                     sizeof(WCHAR));
 187       ProbeForWriteUlong(Context);
 188       if(!RestartScan)
 189       {
 190         SkipEntries = *Context;
 191       }
 192       if(ReturnLength != NULL)
 193       {
 194         ProbeForWriteUlong(ReturnLength);
 195       }
 196     }
 197     _SEH_HANDLE
 198     {
 199       Status = _SEH_GetExceptionCode();
 200     }
 201     _SEH_END;
 202
 203     if(!NT_SUCCESS(Status))
 204     {
 205       DPRINT1("NtQueryDirectoryObject failed, Status: 0x%x\n", Status);
 206       return Status;
 207     }
 208   }
 209   else if(!RestartScan)
 210   {
 211     SkipEntries = *Context;
 212   }
 213
 214   Status = ObReferenceObjectByHandle(DirectoryHandle,
 215                                      DIRECTORY_QUERY,
 216                                      ObDirectoryType,
 217                                      PreviousMode,
 218                                      (PVOID*)&Directory,
 219                                      NULL);
 220   if(NT_SUCCESS(Status))
 221   {
 222     PVOID TemporaryBuffer = ExAllocatePool(PagedPool,
 223                                            BufferLength);
 224     if(TemporaryBuffer != NULL)
 225     {
 226       POBJECT_HEADER EntryHeader;
 227       PLIST_ENTRY ListEntry;
 228       KIRQL OldLevel;
 229       ULONG RequiredSize = 0;
 230       ULONG nDirectories = 0;
 231       POBJECT_DIRECTORY_INFORMATION DirInfo = (POBJECT_DIRECTORY_INFORMATION)TemporaryBuffer;
 232
 233       Status = STATUS_NO_MORE_ENTRIES;
 234
 235       KeAcquireSpinLock(&Directory->Lock, &OldLevel);
 236
 237       for(ListEntry = Directory->head.Flink;
 238           ListEntry != &Directory->head;
 239           ListEntry = ListEntry->Flink)
 240       {
 241         NextEntry++;
 242         if(SkipEntries == 0)
 243         {
 244           PUNICODE_STRING Name, Type;
 245           ULONG EntrySize;
 246
 247           EntryHeader = CONTAINING_RECORD(ListEntry, OBJECT_HEADER, Entry);
 248
 249           /* calculate the size of the required buffer space for this entry */
 250           Name = (HEADER_TO_OBJECT_NAME(EntryHeader)->Name.Length != 0 ? &HEADER_TO_OBJECT_NAME(EntryHeader)->Name : NULL);
 251           Type = &EntryHeader->Type->Name;
 252           EntrySize = sizeof(OBJECT_DIRECTORY_INFORMATION) +
 253                       ((Name != NULL) ? ((ULONG)Name->Length + sizeof(WCHAR)) : 0) +
 254                       (ULONG)EntryHeader->Type->Name.Length + sizeof(WCHAR);
 255
 256           if(RequiredSize + EntrySize <= BufferLength)
 257           {
 258             /* the buffer is large enough to receive this entry. It would've
 259                been much easier if the strings were directly appended to the
 260                OBJECT_DIRECTORY_INFORMATION structured written into the buffer */
 261             if(Name != NULL)
 262               DirInfo->ObjectName = *Name;
 263             else
 264             {
 265               DirInfo->ObjectName.Length = DirInfo->ObjectName.MaximumLength = 0;
 266               DirInfo->ObjectName.Buffer = NULL;
 267             }
 268             DirInfo->ObjectTypeName = *Type;
 269
 270             nDirectories++;
 271             RequiredSize += EntrySize;
 272
 273             Status = STATUS_SUCCESS;
 274
 275             if(ReturnSingleEntry)
 276             {
 277               /* we're only supposed to query one entry, so bail and copy the
 278                  strings to the buffer */
 279               break;
 280             }
 281             DirInfo++;
 282           }
 283           else
 284           {
 285             if(ReturnSingleEntry)
 286             {
 287               /* the buffer is too small, so return the number of bytes that
 288                  would've been required for this query */
 289               RequiredSize += EntrySize;
 290               Status = STATUS_BUFFER_TOO_SMALL;
 291             }
 292
 293             /* we couldn't query this entry, so leave the index that will be stored
 294                in Context to this entry so the caller can query it the next time
 295                he queries (hopefully with a buffer that is large enough then...) */
 296             NextEntry--;
 297
 298             /* just copy the entries that fit into the buffer */
 299             break;
 300           }
 301         }
 302         else
 303         {
 304           /* skip the entry */
 305           SkipEntries--;
 306         }
 307       }
 308
 309       if(!ReturnSingleEntry && ListEntry != &Directory->head)
 310       {
 311         /* there are more entries to enumerate but the buffer is already full.
 312            only tell this to the user if he queries multiple entries */
 313         Status = STATUS_MORE_ENTRIES;
 314       }
 315
 316       if(NT_SUCCESS(Status) && nDirectories > 0)
 317       {
 318         PWSTR strbuf = (PWSTR)((POBJECT_DIRECTORY_INFORMATION)TemporaryBuffer + nDirectories);
 319         PWSTR deststrbuf = (PWSTR)((POBJECT_DIRECTORY_INFORMATION)Buffer + nDirectories);
 320
 321         CopyBytes = nDirectories * sizeof(OBJECT_DIRECTORY_INFORMATION);
 322
 323         /* copy the names from the objects and append them to the list of the
 324            objects. copy to the temporary buffer only because the directory
 325            lock can't be released and the buffer might be pagable memory! */
 326         for(DirInfo = (POBJECT_DIRECTORY_INFORMATION)TemporaryBuffer;
 327             nDirectories > 0;
 328             nDirectories--, DirInfo++)
 329         {
 330           ULONG NameLength;
 331
 332           if(DirInfo->ObjectName.Length > 0)
 333           {
 334             RtlCopyMemory(strbuf,
 335                           DirInfo->ObjectName.Buffer,
 336                           DirInfo->ObjectName.Length);
 337             /* change the buffer pointer to the buffer */
 338             DirInfo->ObjectName.Buffer = deststrbuf;
 339             NameLength = DirInfo->ObjectName.Length / sizeof(WCHAR);
 340             /* NULL-terminate the string */
 341             strbuf[NameLength] = L'\0';
 342             strbuf += NameLength + 1;
 343             deststrbuf += NameLength + 1;
 344
 345             CopyBytes += (NameLength + 1) * sizeof(WCHAR);
 346           }
 347
 348           RtlCopyMemory(strbuf,
 349                         DirInfo->ObjectTypeName.Buffer,
 350                         DirInfo->ObjectTypeName.Length);
 351           /* change the buffer pointer to the buffer */
 352           DirInfo->ObjectTypeName.Buffer = deststrbuf;
 353           NameLength = DirInfo->ObjectTypeName.Length / sizeof(WCHAR);
 354           /* NULL-terminate the string */
 355           strbuf[NameLength] = L'\0';
 356           strbuf += NameLength + 1;
 357           deststrbuf += NameLength + 1;
 358
 359           CopyBytes += (NameLength + 1) * sizeof(WCHAR);
 360         }
 361       }
 362
 363       KeReleaseSpinLock(&Directory->Lock, OldLevel);
 364       ObDereferenceObject(Directory);
 365
 366       if(NT_SUCCESS(Status) || ReturnSingleEntry)
 367       {
 368         _SEH_TRY
 369         {
 370           if(CopyBytes != 0)
 371           {
 372             RtlCopyMemory(Buffer,
 373                           TemporaryBuffer,
 374                           CopyBytes);
 375           }
 376           *Context = NextEntry;
 377           if(ReturnLength != NULL)
 378           {
 379             *ReturnLength = RequiredSize;
 380           }
 381         }
 382         _SEH_HANDLE
 383         {
 384           Status = _SEH_GetExceptionCode();
 385         }
 386         _SEH_END;
 387       }
 388
 389       ExFreePool(TemporaryBuffer);
 390     }
 391     else
 392     {
 393       Status = STATUS_INSUFFICIENT_RESOURCES;
 394     }
 395   }
 396
 397   return Status;
 398 }
 399
 400
 401 /**********************************************************************
 402  * NAME                                         (EXPORTED as Zw)
 403  *      NtCreateDirectoryObject
 404  *
 405  * DESCRIPTION
 406  *      Creates or opens a directory object (a container for other
 407  *      objects).
 408  *
 409  * ARGUMENTS
 410  *      DirectoryHandle (OUT)
 411  *              Caller supplied storage for the handle of the
 412  *              directory.
 413  *
 414  *      DesiredAccess
 415  *              Access desired to the directory.
 416  *
 417  *      ObjectAttributes
 418  *              Object attributes initialized with
 419  *              InitializeObjectAttributes.
 420  *
 421  * RETURN VALUE
 422  *      Status.
 423  */
 424 NTSTATUS STDCALL
 425 NtCreateDirectoryObject (OUT PHANDLE DirectoryHandle,
 426                          IN ACCESS_MASK DesiredAccess,
 427                          IN POBJECT_ATTRIBUTES ObjectAttributes)
 428 {
 429   PDIRECTORY_OBJECT Directory;
 430   HANDLE hDirectory;
 431   KPROCESSOR_MODE PreviousMode;
 432   NTSTATUS Status = STATUS_SUCCESS;
 433
 434   PAGED_CODE();
 435
 436   DPRINT("NtCreateDirectoryObject(DirectoryHandle %x, "
 437          "DesiredAccess %x, ObjectAttributes %x\n",
 438           DirectoryHandle, DesiredAccess, ObjectAttributes);
 439
 440   PreviousMode = ExGetPreviousMode();
 441
 442   if(PreviousMode != KernelMode)
 443   {
 444     _SEH_TRY
 445     {
 446       ProbeForWriteHandle(DirectoryHandle);
 447     }
 448     _SEH_HANDLE
 449     {
 450       Status = _SEH_GetExceptionCode();
 451     }
 452     _SEH_END;
 453
 454     if(!NT_SUCCESS(Status))
 455     {
 456       DPRINT1("NtCreateDirectoryObject failed, Status: 0x%x\n", Status);
 457       return Status;
 458     }
 459   }
 460
 461   Status = ObCreateObject(PreviousMode,
 462                           ObDirectoryType,
 463                           ObjectAttributes,
 464                           PreviousMode,
 465                           NULL,
 466                           sizeof(DIRECTORY_OBJECT),
 467                           0,
 468                           0,
 469                           (PVOID*)&Directory);
 470
 471   if(NT_SUCCESS(Status))
 472   {
 473     Status = ObInsertObject((PVOID)Directory,
 474                             NULL,
 475                             DesiredAccess,
 476                             0,
 477                             NULL,
 478                             &hDirectory);
 479     if (!NT_SUCCESS(Status))
 480     {
 481        ObMakeTemporaryObject(Directory);
 482     }
 483     ObDereferenceObject(Directory);
 484
 485     if(NT_SUCCESS(Status))
 486     {
 487       _SEH_TRY
 488       {
 489         *DirectoryHandle = hDirectory;
 490       }
 491       _SEH_HANDLE
 492       {
 493         Status = _SEH_GetExceptionCode();
 494       }
 495       _SEH_END;
 496     }
 497   }
 498
 499   return Status;
 500 }
 501
 502 /* EOF */