ntoskrnl/ob/oblink.c

   1 /*
   2 * PROJECT:         ReactOS Kernel
   3 * LICENSE:         GPL - See COPYING in the top level directory
   4 * FILE:            ntoskrnl/ob/oblink.c
   5 * PURPOSE:         Implements symbolic links
   6 * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7 *                  David Welch (welch@mcmail.com)
   8 */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* GLOBALS ******************************************************************/
  17
  18 POBJECT_TYPE ObpSymbolicLinkObjectType = NULL;
  19
  20 /* PRIVATE FUNCTIONS *********************************************************/
  21
  22 VOID
  23 NTAPI
  24 ObpDeleteSymbolicLinkName(IN POBJECT_SYMBOLIC_LINK SymbolicLink)
  25 {
  26     POBJECT_HEADER ObjectHeader;
  27     POBJECT_HEADER_NAME_INFO ObjectNameInfo;
  28
  29     /* FIXME: Need to support Device maps */
  30
  31     /* Get header data */
  32     ObjectHeader = OBJECT_TO_OBJECT_HEADER(SymbolicLink);
  33     ObjectNameInfo = ObpReferenceNameInfo(ObjectHeader);
  34
  35     /* Check if we are not actually in a directory with a device map */
  36     if (!(ObjectNameInfo) ||
  37         !(ObjectNameInfo->Directory) /*||
  38         !(ObjectNameInfo->Directory->DeviceMap)*/)
  39     {
  40         ObpDereferenceNameInfo(ObjectNameInfo);
  41         return;
  42     }
  43
  44     /* Check if it's a DOS drive letter, and remove the entry from drive map if needed */
  45     if (SymbolicLink->DosDeviceDriveIndex != 0 &&
  46         ObjectNameInfo->Name.Length == 2 * sizeof(WCHAR) &&
  47         ObjectNameInfo->Name.Buffer[1] == L':' &&
  48         ( (ObjectNameInfo->Name.Buffer[0] >= L'A' &&
  49             ObjectNameInfo->Name.Buffer[0] <= L'Z') ||
  50           (ObjectNameInfo->Name.Buffer[0] >= L'a' &&
  51             ObjectNameInfo->Name.Buffer[0] <= L'z') ))
  52     {
  53         /* Remove the drive entry */
  54         KeAcquireGuardedMutex(&ObpDeviceMapLock);
  55         ObSystemDeviceMap->DriveType[SymbolicLink->DosDeviceDriveIndex-1] =
  56             DOSDEVICE_DRIVE_UNKNOWN;
  57         ObSystemDeviceMap->DriveMap &=
  58             ~(1 << (SymbolicLink->DosDeviceDriveIndex-1));
  59         KeReleaseGuardedMutex(&ObpDeviceMapLock);
  60
  61         /* Reset the drive index, valid drive index starts from 1 */
  62         SymbolicLink->DosDeviceDriveIndex = 0;
  63     }
  64
  65     ObpDereferenceNameInfo(ObjectNameInfo);
  66 }
  67
  68 NTSTATUS
  69 NTAPI
  70 ObpParseSymbolicLinkToIoDeviceObject(IN POBJECT_DIRECTORY SymbolicLinkDirectory,
  71                                      IN OUT POBJECT_DIRECTORY *Directory,
  72                                      IN OUT PUNICODE_STRING TargetPath,
  73                                      IN OUT POBP_LOOKUP_CONTEXT Context,
  74                                      OUT PVOID *Object)
  75 {
  76     UNICODE_STRING Name;
  77     BOOLEAN ManualUnlock;
  78
  79     if (! TargetPath || ! Object || ! Context || ! Directory ||
  80         ! SymbolicLinkDirectory)
  81     {
  82         return STATUS_INVALID_PARAMETER;
  83     }
  84
  85     /* FIXME: Need to support Device maps */
  86
  87     /* Try walking the target path and open each part of the path */
  88     while (TargetPath->Length)
  89     {
  90         /* Strip '\' if present at the beginning of the target path */
  91         if (TargetPath->Length >= sizeof(OBJ_NAME_PATH_SEPARATOR)&&
  92             TargetPath->Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
  93         {
  94             TargetPath->Buffer++;
  95             TargetPath->Length -= sizeof(OBJ_NAME_PATH_SEPARATOR);
  96         }
  97
  98         /* Remember the current component of the target path */
  99         Name = *TargetPath;
 100
 101         /* Move forward to the next component of the target path */
 102         while (TargetPath->Length >= sizeof(OBJ_NAME_PATH_SEPARATOR))
 103         {
 104             if (TargetPath->Buffer[0] != OBJ_NAME_PATH_SEPARATOR)
 105             {
 106                 TargetPath->Buffer++;
 107                 TargetPath->Length -= sizeof(OBJ_NAME_PATH_SEPARATOR);
 108             }
 109             else
 110                 break;
 111         }
 112
 113         Name.Length -= TargetPath->Length;
 114
 115         /* Finished processing the entire path, stop */
 116         if (! Name.Length)
 117             break;
 118
 119         /*
 120          * Make sure a deadlock does not occur as an exclusive lock on a pushlock
 121          * would have already taken one in ObpLookupObjectName() on the parent
 122          * directory where the symlink is being created [ObInsertObject()].
 123          * Prevent recursive locking by faking lock state in the lookup context
 124          * when the current directory is same as the parent directory where
 125          * the symlink is being created. If the lock state is not faked,
 126          * ObpLookupEntryDirectory() will try to get a recursive lock on the
 127          * pushlock and hang. For e.g. this happens when a substed drive is pointed to
 128          * another substed drive.
 129          */
 130         if (*Directory == SymbolicLinkDirectory && ! Context->DirectoryLocked)
 131         {
 132             /* Fake lock state so that ObpLookupEntryDirectory() doesn't attempt a lock */
 133             ManualUnlock = TRUE;
 134             Context->DirectoryLocked = TRUE;
 135         }
 136         else
 137             ManualUnlock = FALSE;
 138
 139         *Object = ObpLookupEntryDirectory(*Directory,
 140                                           &Name,
 141                                           0,
 142                                           FALSE,
 143                                           Context);
 144
 145         /* Locking was faked, undo it now */
 146         if (*Directory == SymbolicLinkDirectory && ManualUnlock)
 147             Context->DirectoryLocked = FALSE;
 148
 149         /* Lookup failed, stop */
 150         if (! *Object)
 151             break;
 152
 153         if (OBJECT_TO_OBJECT_HEADER(*Object)->Type == ObpDirectoryObjectType)
 154         {
 155             /* Make this current directory, and continue search */
 156             *Directory = (POBJECT_DIRECTORY)*Object;
 157         }
 158         else if (OBJECT_TO_OBJECT_HEADER(*Object)->Type == ObpSymbolicLinkObjectType &&
 159             (((POBJECT_SYMBOLIC_LINK)*Object)->DosDeviceDriveIndex == 0))
 160         {
 161             /* Symlink points to another initialized symlink, ask caller to reparse */
 162             *Directory = ObpRootDirectoryObject;
 163             TargetPath = &((POBJECT_SYMBOLIC_LINK)*Object)->LinkTarget;
 164             return STATUS_REPARSE_OBJECT;
 165         }
 166         else
 167         {
 168             /* Neither directory or symlink, stop */
 169             break;
 170         }
 171     }
 172
 173     /* Return a valid object, only if object type is IoDeviceObject */
 174     if (*Object &&
 175         OBJECT_TO_OBJECT_HEADER(*Object)->Type != IoDeviceObjectType)
 176     {
 177         *Object = NULL;
 178     }
 179     return STATUS_SUCCESS;
 180 }
 181
 182 VOID
 183 NTAPI
 184 ObpCreateSymbolicLinkName(IN POBJECT_SYMBOLIC_LINK SymbolicLink)
 185 {
 186     POBJECT_HEADER ObjectHeader;
 187     POBJECT_HEADER_NAME_INFO ObjectNameInfo;
 188     PVOID Object = NULL;
 189     POBJECT_DIRECTORY Directory;
 190     UNICODE_STRING TargetPath;
 191     NTSTATUS Status;
 192     ULONG DriveType = DOSDEVICE_DRIVE_CALCULATE;
 193     ULONG ReparseCnt;
 194     const ULONG MaxReparseAttempts = 20;
 195     OBP_LOOKUP_CONTEXT Context;
 196
 197     /* FIXME: Need to support Device maps */
 198
 199     /* Get header data */
 200     ObjectHeader = OBJECT_TO_OBJECT_HEADER(SymbolicLink);
 201     ObjectNameInfo = ObpReferenceNameInfo(ObjectHeader);
 202
 203     /* Check if we are not actually in a directory with a device map */
 204     if (!(ObjectNameInfo) ||
 205         !(ObjectNameInfo->Directory) /*||
 206         !(ObjectNameInfo->Directory->DeviceMap)*/)
 207     {
 208         ObpDereferenceNameInfo(ObjectNameInfo);
 209         return;
 210     }
 211
 212     /* Check if it's a DOS drive letter, and set the drive index accordingly */
 213     if (ObjectNameInfo->Name.Length == 2 * sizeof(WCHAR) &&
 214         ObjectNameInfo->Name.Buffer[1] == L':' &&
 215         ( (ObjectNameInfo->Name.Buffer[0] >= L'A' &&
 216             ObjectNameInfo->Name.Buffer[0] <= L'Z') ||
 217           (ObjectNameInfo->Name.Buffer[0] >= L'a' &&
 218             ObjectNameInfo->Name.Buffer[0] <= L'z') ))
 219     {
 220         SymbolicLink->DosDeviceDriveIndex =
 221             RtlUpcaseUnicodeChar(ObjectNameInfo->Name.Buffer[0]) - L'A';
 222         /* The Drive index start from 1 */
 223         SymbolicLink->DosDeviceDriveIndex++;
 224
 225         /* Initialize lookup context */
 226         ObpInitializeLookupContext(&Context);
 227
 228         /* Start the search from the root */
 229         Directory = ObpRootDirectoryObject;
 230         TargetPath = SymbolicLink->LinkTarget;
 231
 232         /*
 233          * Locate the IoDeviceObject if any this symbolic link points to.
 234          * To prevent endless reparsing, setting an upper limit on the
 235          * number of reparses.
 236          */
 237         Status = STATUS_REPARSE_OBJECT;
 238         ReparseCnt = 0;
 239         while (Status == STATUS_REPARSE_OBJECT &&
 240                ReparseCnt < MaxReparseAttempts)
 241         {
 242             Status =
 243                 ObpParseSymbolicLinkToIoDeviceObject(ObjectNameInfo->Directory,
 244                                                      &Directory,
 245                                                      &TargetPath,
 246                                                      &Context,
 247                                                      &Object);
 248             if (Status == STATUS_REPARSE_OBJECT)
 249                 ReparseCnt++;
 250         }
 251
 252         /* Cleanup lookup context */
 253         ObpReleaseLookupContext(&Context);
 254
 255         /* Error, or max resparse attemtps exceeded */
 256         if (! NT_SUCCESS(Status) || ReparseCnt >= MaxReparseAttempts)
 257         {
 258             /* Cleanup */
 259             ObpDereferenceNameInfo(ObjectNameInfo);
 260             return;
 261         }
 262
 263         if (Object)
 264         {
 265             /* Calculate the drive type */
 266             switch(((PDEVICE_OBJECT)Object)->DeviceType)
 267             {
 268             case FILE_DEVICE_VIRTUAL_DISK:
 269                 DriveType = DOSDEVICE_DRIVE_RAMDISK;
 270                 break;
 271             case FILE_DEVICE_CD_ROM:
 272             case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
 273                 DriveType = DOSDEVICE_DRIVE_CDROM;
 274                 break;
 275             case FILE_DEVICE_DISK:
 276             case FILE_DEVICE_DISK_FILE_SYSTEM:
 277             case FILE_DEVICE_FILE_SYSTEM:
 278                 if (((PDEVICE_OBJECT)Object)->Characteristics & FILE_REMOVABLE_MEDIA)
 279                     DriveType = DOSDEVICE_DRIVE_REMOVABLE;
 280                 else
 281                     DriveType = DOSDEVICE_DRIVE_FIXED;
 282                 break;
 283             case FILE_DEVICE_NETWORK:
 284             case FILE_DEVICE_NETWORK_FILE_SYSTEM:
 285                 DriveType = DOSDEVICE_DRIVE_REMOTE;
 286                 break;
 287             default:
 288                 DPRINT1("Device Type %lu for %wZ is not known or unhandled\n",
 289                         ((PDEVICE_OBJECT)Object)->DeviceType,
 290                         &SymbolicLink->LinkTarget);
 291                 DriveType = DOSDEVICE_DRIVE_UNKNOWN;
 292             }
 293         }
 294
 295         /* Add a new drive entry */
 296         KeAcquireGuardedMutex(&ObpDeviceMapLock);
 297         ObSystemDeviceMap->DriveType[SymbolicLink->DosDeviceDriveIndex-1] =
 298             (UCHAR)DriveType;
 299         ObSystemDeviceMap->DriveMap |=
 300             1 << (SymbolicLink->DosDeviceDriveIndex-1);
 301         KeReleaseGuardedMutex(&ObpDeviceMapLock);
 302     }
 303
 304     /* Cleanup */
 305     ObpDereferenceNameInfo(ObjectNameInfo);
 306 }
 307
 308 /*++
 309 * @name ObpDeleteSymbolicLink
 310 *
 311 *     The ObpDeleteSymbolicLink routine <FILLMEIN>
 312 *
 313 * @param ObjectBody
 314 *        <FILLMEIN>
 315 *
 316 * @return None.
 317 *
 318 * @remarks None.
 319 *
 320 *--*/
 321 VOID
 322 NTAPI
 323 ObpDeleteSymbolicLink(PVOID ObjectBody)
 324 {
 325     POBJECT_SYMBOLIC_LINK SymlinkObject = (POBJECT_SYMBOLIC_LINK)ObjectBody;
 326
 327     /* Make sure that the symbolic link has a name */
 328     if (SymlinkObject->LinkTarget.Buffer)
 329     {
 330         /* Free the name */
 331         ExFreePool(SymlinkObject->LinkTarget.Buffer);
 332         SymlinkObject->LinkTarget.Buffer = NULL;
 333     }
 334 }
 335
 336 /*++
 337 * @name ObpParseSymbolicLink
 338 *
 339 *     The ObpParseSymbolicLink routine <FILLMEIN>
 340 *
 341 * @param Object
 342 *        <FILLMEIN>
 343 *
 344 * @param NextObject
 345 *        <FILLMEIN>
 346 *
 347 * @param FullPath
 348 *        <FILLMEIN>
 349 *
 350 * @param RemainingPath
 351 *        <FILLMEIN>
 352 *
 353 * @param Attributes
 354 *        <FILLMEIN>
 355 *
 356 * @return STATUS_SUCCESS or appropriate error value.
 357 *
 358 * @remarks None.
 359 *
 360 *--*/
 361 NTSTATUS
 362 NTAPI
 363 ObpParseSymbolicLink(IN PVOID ParsedObject,
 364                      IN PVOID ObjectType,
 365                      IN OUT PACCESS_STATE AccessState,
 366                      IN KPROCESSOR_MODE AccessMode,
 367                      IN ULONG Attributes,
 368                      IN OUT PUNICODE_STRING FullPath,
 369                      IN OUT PUNICODE_STRING RemainingName,
 370                      IN OUT PVOID Context OPTIONAL,
 371                      IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
 372                      OUT PVOID *NextObject)
 373 {
 374     POBJECT_SYMBOLIC_LINK SymlinkObject = (POBJECT_SYMBOLIC_LINK)ParsedObject;
 375     PUNICODE_STRING TargetPath;
 376     PWSTR NewTargetPath;
 377     ULONG LengthUsed, MaximumLength, TempLength;
 378     NTSTATUS Status;
 379     PAGED_CODE();
 380
 381     /* Assume failure */
 382     *NextObject = NULL;
 383
 384     /* Check if we're out of name to parse */
 385     if (!RemainingName->Length)
 386     {
 387         /* Check if we got an object type */
 388         if (ObjectType)
 389         {
 390             /* Reference the object only */
 391             Status = ObReferenceObjectByPointer(ParsedObject,
 392                                                 0,
 393                                                 ObjectType,
 394                                                 AccessMode);
 395             if (NT_SUCCESS(Status))
 396             {
 397                 /* Return it */
 398                 *NextObject = ParsedObject;
 399             }
 400
 401             if ((NT_SUCCESS(Status)) || (Status != STATUS_OBJECT_TYPE_MISMATCH))
 402             {
 403                 /* Fail */
 404                 return Status;
 405             }
 406         }
 407     }
 408     else if (RemainingName->Buffer[0] != OBJ_NAME_PATH_SEPARATOR)
 409     {
 410         /* Symbolic links must start with a backslash */
 411         return STATUS_OBJECT_TYPE_MISMATCH;
 412     }
 413
 414     /* Check if this symlink is bound to a specific object */
 415     if (SymlinkObject->LinkTargetObject)
 416     {
 417         UNIMPLEMENTED;
 418     }
 419
 420     /* Set the target path and length */
 421     TargetPath = &SymlinkObject->LinkTarget;
 422     TempLength = TargetPath->Length;
 423
 424     /*
 425      * Strip off the extra trailing '\', if we don't do this we will end up
 426      * adding a extra '\' between TargetPath and RemainingName
 427      * causing caller's like ObpLookupObjectName() to fail.
 428      */
 429     if (TempLength && RemainingName->Length)
 430     {
 431         /* The target and remaining names aren't empty, so check for slashes */
 432         if ((TargetPath->Buffer[TempLength / sizeof(WCHAR) - 1] ==
 433             OBJ_NAME_PATH_SEPARATOR) &&
 434             (RemainingName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR))
 435         {
 436             /* Reduce the length by one to cut off the extra '\' */
 437             TempLength -= sizeof(OBJ_NAME_PATH_SEPARATOR);
 438         }
 439     }
 440
 441     /* Calculate the new length */
 442     LengthUsed = TempLength + RemainingName->Length;
 443
 444     /* Check if it's not too much */
 445     if (LengthUsed > 0xFFF0)
 446         return STATUS_NAME_TOO_LONG;
 447
 448     /* Optimization: check if the new name is shorter */
 449     if (FullPath->MaximumLength <= LengthUsed)
 450     {
 451         /* It's not, allocate a new one */
 452         MaximumLength = LengthUsed + sizeof(WCHAR);
 453         NewTargetPath = ExAllocatePoolWithTag(NonPagedPool,
 454                                               MaximumLength,
 455                                               OB_NAME_TAG);
 456         if (!NewTargetPath) return STATUS_INSUFFICIENT_RESOURCES;
 457     }
 458     else
 459     {
 460         /* It is! Reuse the name... */
 461         MaximumLength = FullPath->MaximumLength;
 462         NewTargetPath = FullPath->Buffer;
 463     }
 464
 465     /* Make sure we have a length */
 466     if (RemainingName->Length)
 467     {
 468         /* Copy the new path */
 469         RtlMoveMemory((PVOID)((ULONG_PTR)NewTargetPath + TempLength),
 470                       RemainingName->Buffer,
 471                       RemainingName->Length);
 472     }
 473
 474     /* Copy the target path and null-terminate it */
 475     RtlCopyMemory(NewTargetPath, TargetPath->Buffer, TempLength);
 476     NewTargetPath[LengthUsed / sizeof(WCHAR)] = UNICODE_NULL;
 477
 478     /* If the optimization didn't work, free the old buffer */
 479     if (NewTargetPath != FullPath->Buffer) ExFreePool(FullPath->Buffer);
 480
 481     /* Update the path values */
 482     FullPath->Length = (USHORT)LengthUsed;
 483     FullPath->MaximumLength = (USHORT)MaximumLength;
 484     FullPath->Buffer = NewTargetPath;
 485
 486     /* Tell the parse routine to start reparsing */
 487     return STATUS_REPARSE;
 488 }
 489
 490 /* PUBLIC FUNCTIONS **********************************************************/
 491
 492 /*++
 493 * @name NtCreateSymbolicLinkObject
 494 * @implemented NT4
 495 *
 496 *     The NtCreateSymbolicLinkObject opens or creates a symbolic link object.
 497 *
 498 * @param LinkHandle
 499 *        Variable which receives the symlink handle.
 500 *
 501 * @param DesiredAccess
 502 *        Desired access to the symlink.
 503 *
 504 * @param ObjectAttributes
 505 *        Structure describing the symlink.
 506 *
 507 * @param LinkTarget
 508 *        Unicode string defining the symlink's target
 509 *
 510 * @return STATUS_SUCCESS or appropriate error value.
 511 *
 512 * @remarks None.
 513 *
 514 *--*/
 515 NTSTATUS
 516 NTAPI
 517 NtCreateSymbolicLinkObject(OUT PHANDLE LinkHandle,
 518                            IN ACCESS_MASK DesiredAccess,
 519                            IN POBJECT_ATTRIBUTES ObjectAttributes,
 520                            IN PUNICODE_STRING LinkTarget)
 521 {
 522     HANDLE hLink;
 523     POBJECT_SYMBOLIC_LINK SymbolicLink;
 524     UNICODE_STRING CapturedLinkTarget;
 525     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 526     NTSTATUS Status;
 527     PAGED_CODE();
 528
 529     /* Check if we need to probe parameters */
 530     if (PreviousMode != KernelMode)
 531     {
 532         _SEH2_TRY
 533         {
 534             /* Probe the target */
 535             CapturedLinkTarget = ProbeForReadUnicodeString(LinkTarget);
 536             ProbeForRead(CapturedLinkTarget.Buffer,
 537                          CapturedLinkTarget.MaximumLength,
 538                          sizeof(WCHAR));
 539
 540             /* Probe the return handle */
 541             ProbeForWriteHandle(LinkHandle);
 542         }
 543         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 544         {
 545             /* Return the exception code */
 546             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 547         }
 548         _SEH2_END;
 549     }
 550     else
 551     {
 552         /* No need to capture */
 553         CapturedLinkTarget = *LinkTarget;
 554     }
 555
 556     /* Check if the maximum length is odd */
 557     if (CapturedLinkTarget.MaximumLength % sizeof(WCHAR))
 558     {
 559         /* Round it down */
 560         CapturedLinkTarget.MaximumLength =
 561             (USHORT)ALIGN_DOWN(CapturedLinkTarget.MaximumLength, WCHAR);
 562     }
 563
 564     /* Fail if the length is odd, or if the maximum is smaller or 0 */
 565     if ((CapturedLinkTarget.Length % sizeof(WCHAR)) ||
 566         (CapturedLinkTarget.MaximumLength < CapturedLinkTarget.Length) ||
 567         !(CapturedLinkTarget.MaximumLength))
 568     {
 569         /* This message is displayed on the debugger in Windows */
 570         DbgPrint("OB: Invalid symbolic link target - %wZ\n",
 571                  &CapturedLinkTarget);
 572         return STATUS_INVALID_PARAMETER;
 573     }
 574
 575     /* Create the object */
 576     Status = ObCreateObject(PreviousMode,
 577                             ObpSymbolicLinkObjectType,
 578                             ObjectAttributes,
 579                             PreviousMode,
 580                             NULL,
 581                             sizeof(OBJECT_SYMBOLIC_LINK),
 582                             0,
 583                             0,
 584                             (PVOID*)&SymbolicLink);
 585     if (NT_SUCCESS(Status))
 586     {
 587         /* Success! Fill in the creation time immediately */
 588         KeQuerySystemTime(&SymbolicLink->CreationTime);
 589
 590         /* Setup the target name */
 591         SymbolicLink->LinkTarget.Length = CapturedLinkTarget.Length;
 592         SymbolicLink->LinkTarget.MaximumLength = CapturedLinkTarget.MaximumLength;
 593         SymbolicLink->LinkTarget.Buffer =
 594             ExAllocatePoolWithTag(PagedPool,
 595                                   CapturedLinkTarget.MaximumLength,
 596                                   TAG_SYMLINK_TARGET);
 597         if (!SymbolicLink->LinkTarget.Buffer)
 598         {
 599             /* Dereference the symbolic link object and fail */
 600             ObDereferenceObject(SymbolicLink);
 601             return STATUS_NO_MEMORY;
 602         }
 603
 604         /* Copy it */
 605         _SEH2_TRY
 606         {
 607             RtlCopyMemory(SymbolicLink->LinkTarget.Buffer,
 608                           CapturedLinkTarget.Buffer,
 609                           CapturedLinkTarget.MaximumLength);
 610         }
 611         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 612         {
 613             ObDereferenceObject(SymbolicLink);
 614             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 615         }
 616         _SEH2_END;
 617
 618         /* Initialize the remaining name, dos drive index and target object */
 619         SymbolicLink->LinkTargetObject = NULL;
 620         SymbolicLink->DosDeviceDriveIndex = 0;
 621         RtlInitUnicodeString(&SymbolicLink->LinkTargetRemaining, NULL);
 622
 623         /* Insert it into the object tree */
 624         Status = ObInsertObject(SymbolicLink,
 625                                 NULL,
 626                                 DesiredAccess,
 627                                 0,
 628                                 NULL,
 629                                 &hLink);
 630         if (NT_SUCCESS(Status))
 631         {
 632             _SEH2_TRY
 633             {
 634                 /* Return the handle to caller */
 635                 *LinkHandle = hLink;
 636             }
 637             _SEH2_EXCEPT(ExSystemExceptionFilter())
 638             {
 639                 /* Get exception code */
 640                 Status = _SEH2_GetExceptionCode();
 641             }
 642             _SEH2_END;
 643         }
 644     }
 645
 646     /* Return status to caller */
 647     return Status;
 648 }
 649
 650 /*++
 651 * @name NtOpenSymbolicLinkObject
 652 * @implemented NT4
 653 *
 654 *     The NtOpenSymbolicLinkObject opens a symbolic link object.
 655 *
 656 * @param LinkHandle
 657 *        Variable which receives the symlink handle.
 658 *
 659 * @param DesiredAccess
 660 *        Desired access to the symlink.
 661 *
 662 * @param ObjectAttributes
 663 *        Structure describing the symlink.
 664 *
 665 * @return STATUS_SUCCESS or appropriate error value.
 666 *
 667 * @remarks None.
 668 *
 669 *--*/
 670 NTSTATUS
 671 NTAPI
 672 NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle,
 673                          IN ACCESS_MASK DesiredAccess,
 674                          IN POBJECT_ATTRIBUTES ObjectAttributes)
 675 {
 676     HANDLE hLink;
 677     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 678     NTSTATUS Status;
 679     PAGED_CODE();
 680
 681     /* Check if we need to probe parameters */
 682     if (PreviousMode != KernelMode)
 683     {
 684         _SEH2_TRY
 685         {
 686             /* Probe the return handle */
 687             ProbeForWriteHandle(LinkHandle);
 688         }
 689         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 690         {
 691             /* Return the exception code */
 692             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 693         }
 694         _SEH2_END;
 695     }
 696
 697     /* Open the object */
 698     Status = ObOpenObjectByName(ObjectAttributes,
 699                                 ObpSymbolicLinkObjectType,
 700                                 PreviousMode,
 701                                 NULL,
 702                                 DesiredAccess,
 703                                 NULL,
 704                                 &hLink);
 705
 706     _SEH2_TRY
 707     {
 708         /* Return the handle to caller */
 709         *LinkHandle = hLink;
 710     }
 711     _SEH2_EXCEPT(ExSystemExceptionFilter())
 712     {
 713         /* Get exception code */
 714         Status = _SEH2_GetExceptionCode();
 715     }
 716     _SEH2_END;
 717
 718     /* Return status to caller */
 719     return Status;
 720 }
 721
 722 /*++
 723 * @name NtQuerySymbolicLinkObject
 724 * @implemented NT4
 725 *
 726 *     The NtQuerySymbolicLinkObject queries a symbolic link object.
 727 *
 728 * @param LinkHandle
 729 *        Symlink handle to query
 730 *
 731 * @param LinkTarget
 732 *        Unicode string defining the symlink's target
 733 *
 734 * @param ResultLength
 735 *        Caller supplied storage for the number of bytes written (or NULL).
 736 *
 737 * @return STATUS_SUCCESS or appropriate error value.
 738 *
 739 * @remarks None.
 740 *
 741 *--*/
 742 NTSTATUS
 743 NTAPI
 744 NtQuerySymbolicLinkObject(IN HANDLE LinkHandle,
 745                           OUT PUNICODE_STRING LinkTarget,
 746                           OUT PULONG ResultLength OPTIONAL)
 747 {
 748     UNICODE_STRING SafeLinkTarget = { 0, 0, NULL };
 749     POBJECT_SYMBOLIC_LINK SymlinkObject;
 750     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 751     NTSTATUS Status;
 752     ULONG LengthUsed;
 753     PAGED_CODE();
 754
 755     if (PreviousMode != KernelMode)
 756     {
 757         _SEH2_TRY
 758         {
 759             /* Probe the unicode string for read and write */
 760             ProbeForWriteUnicodeString(LinkTarget);
 761
 762             /* Probe the unicode string's buffer for write */
 763             SafeLinkTarget = *LinkTarget;
 764             ProbeForWrite(SafeLinkTarget.Buffer,
 765                           SafeLinkTarget.MaximumLength,
 766                           sizeof(WCHAR));
 767
 768             /* Probe the return length */
 769             if (ResultLength) ProbeForWriteUlong(ResultLength);
 770         }
 771         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 772         {
 773             /* Return the exception code */
 774             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 775         }
 776         _SEH2_END;
 777     }
 778     else
 779     {
 780         /* No need to probe */
 781         SafeLinkTarget = *LinkTarget;
 782     }
 783
 784     /* Reference the object */
 785     Status = ObReferenceObjectByHandle(LinkHandle,
 786                                        SYMBOLIC_LINK_QUERY,
 787                                        ObpSymbolicLinkObjectType,
 788                                        PreviousMode,
 789                                        (PVOID *)&SymlinkObject,
 790                                        NULL);
 791     if (NT_SUCCESS(Status))
 792     {
 793         /* Lock the object */
 794         ObpAcquireObjectLock(OBJECT_TO_OBJECT_HEADER(SymlinkObject));
 795
 796         /*
 797          * So here's the thing: If you specify a return length, then the
 798          * implementation will use the maximum length. If you don't, then
 799          * it will use the length.
 800          */
 801         LengthUsed = ResultLength ? SymlinkObject->LinkTarget.MaximumLength :
 802                                     SymlinkObject->LinkTarget.Length;
 803
 804         /* Enter SEH so we can safely copy */
 805         _SEH2_TRY
 806         {
 807             /* Make sure our buffer will fit */
 808             if (LengthUsed <= SafeLinkTarget.MaximumLength)
 809             {
 810                 /* Copy the buffer */
 811                 RtlCopyMemory(SafeLinkTarget.Buffer,
 812                               SymlinkObject->LinkTarget.Buffer,
 813                               LengthUsed);
 814
 815                 /* Copy the new length */
 816                 LinkTarget->Length = SymlinkObject->LinkTarget.Length;
 817             }
 818             else
 819             {
 820                 /* Otherwise set the failure status */
 821                 Status = STATUS_BUFFER_TOO_SMALL;
 822             }
 823
 824             /* In both cases, check if the required length was requested */
 825             if (ResultLength)
 826             {
 827                 /* Then return it */
 828                 *ResultLength = SymlinkObject->LinkTarget.MaximumLength;
 829             }
 830         }
 831         _SEH2_EXCEPT(ExSystemExceptionFilter())
 832         {
 833             /* Get the error code */
 834             Status = _SEH2_GetExceptionCode();
 835         }
 836         _SEH2_END;
 837
 838         /* Unlock and dereference the object */
 839         ObpReleaseObjectLock(OBJECT_TO_OBJECT_HEADER(SymlinkObject));
 840         ObDereferenceObject(SymlinkObject);
 841     }
 842
 843     /* Return query status */
 844     return Status;
 845 }
 846
 847 /* EOF */