src/WINNT/afsrdr/kernel/lib/AFSNameSupport.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSNameSupport.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // AFSLocateNameEntry
  43 //
  44 // On entry, *VolumeCB must have a held ReferenceCount provided by
  45 // the caller which will not be released.  On successful exit, *OutVolumeCB
  46 // will be assigned the new current volume with a held ReferenceCount.
  47 //
  48 // On entry, *ParentDirectoryCB must have a held DirOpenReferenceCount
  49 // provided by the caller.
  50 //
  51
  52 NTSTATUS
  53 AFSLocateNameEntry( IN GUID *AuthGroup,
  54                     IN PFILE_OBJECT FileObject,
  55                     IN OUT UNICODE_STRING *RootPathName,
  56                     IN UNICODE_STRING *ParsedPathName,
  57                     IN AFSNameArrayHdr *NameArray,
  58                     IN ULONG Flags,
  59                     IN AFSVolumeCB *VolumeCB,
  60                     IN AFSDirectoryCB *ParentDirectoryCB,
  61                     OUT AFSVolumeCB **OutVolumeCB,
  62                     OUT LONG *OutVolumeReferenceReason,
  63                     OUT AFSDirectoryCB **OutParentDirectoryCB,
  64                     OUT AFSDirectoryCB **OutDirectoryCB,
  65                     OUT PUNICODE_STRING ComponentName)
  66 {
  67
  68     NTSTATUS          ntStatus = STATUS_SUCCESS;
  69     UNICODE_STRING    uniPathName, uniComponentName, uniRemainingPath, uniSearchName, uniFullPathName;
  70     ULONG             ulCRC = 0;
  71     AFSDirectoryCB   *pDirEntry = NULL, *pParentDirEntry = NULL;
  72     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
  73     UNICODE_STRING    uniSysName;
  74     ULONG             ulSubstituteIndex = 0;
  75     BOOLEAN           bSubstituteName = FALSE;
  76     AFSNameArrayHdr  *pNameArray = NameArray;
  77     BOOLEAN           bAllocatedSymLinkBuffer = FALSE;
  78     UNICODE_STRING    uniRelativeName, uniNoOpName;
  79     AFSObjectInfoCB  *pCurrentObject = NULL;
  80     AFSObjectInfoCB  *pParentObjectInfo = NULL;
  81     AFSVolumeCB      *pCurrentVolume = NULL;
  82     AFSVolumeCB      *pTargetVolume = NULL;
  83     BOOLEAN           bReleaseCurrentVolume = FALSE;
  84     LONG              VolumeReferenceReason;
  85     BOOLEAN           bSubstitutedName = FALSE;
  86     LONG              lCount;
  87
  88     __Enter
  89     {
  90
  91         ASSERT( *OutVolumeCB != VolumeCB);
  92
  93         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  94                       AFS_TRACE_LEVEL_VERBOSE_2,
  95                       "AFSLocateNameEntry (FO: %p) Processing full name %wZ\n",
  96                       FileObject,
  97                       RootPathName);
  98
  99         RtlInitUnicodeString( &uniSysName,
 100                               L"*@SYS");
 101
 102         RtlInitUnicodeString( &uniRelativeName,
 103                               L"..");
 104
 105         RtlInitUnicodeString( &uniNoOpName,
 106                               L".");
 107
 108         //
 109         // Cleanup some parameters
 110         //
 111
 112         if( ComponentName != NULL)
 113         {
 114
 115             ComponentName->Length = 0;
 116             ComponentName->MaximumLength = 0;
 117             ComponentName->Buffer = NULL;
 118         }
 119
 120         //
 121         // We will parse through the filename, locating the directory nodes until we encounter a cache miss
 122         // Starting at the root node
 123         //
 124
 125         pParentDirEntry = NULL;
 126
 127         pDirEntry = ParentDirectoryCB;
 128
 129         pCurrentVolume = VolumeCB;
 130
 131         VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
 132
 133         lCount = AFSVolumeIncrement( pCurrentVolume,
 134                                      VolumeReferenceReason);
 135
 136         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 137                       AFS_TRACE_LEVEL_VERBOSE,
 138                       "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
 139                       pCurrentVolume,
 140                       VolumeReferenceReason,
 141                       lCount);
 142
 143         bReleaseCurrentVolume = TRUE;
 144
 145         uniPathName = *ParsedPathName;
 146
 147         uniFullPathName = *RootPathName;
 148
 149         uniComponentName.Length = uniComponentName.MaximumLength = 0;
 150         uniComponentName.Buffer = NULL;
 151
 152         uniRemainingPath.Length = uniRemainingPath.MaximumLength = 0;
 153         uniRemainingPath.Buffer = NULL;
 154
 155         uniSearchName.Length = uniSearchName.MaximumLength = 0;
 156         uniSearchName.Buffer = NULL;
 157
 158         while( TRUE)
 159         {
 160
 161             ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
 162
 163             ASSERT( pDirEntry->DirOpenReferenceCount > 0);
 164
 165             //
 166             // Check our total link count for this name array
 167             //
 168
 169             if( pNameArray->LinkCount >= (LONG)pDevExt->Specific.RDR.MaxLinkCount)
 170             {
 171
 172                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 173             }
 174
 175             pCurrentObject = pDirEntry->ObjectInformation;
 176
 177             KeQueryTickCount( &pCurrentObject->LastAccessCount);
 178
 179             //
 180             // Check that the directory entry is not deleted or pending delete
 181             //
 182
 183             if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED))
 184             {
 185
 186                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 187                               AFS_TRACE_LEVEL_ERROR,
 188                               "AFSLocateNameEntry (FO: %p) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 189                               FileObject,
 190                               &pDirEntry->NameInformation.FileName,
 191                               pCurrentObject->FileId.Cell,
 192                               pCurrentObject->FileId.Volume,
 193                               pCurrentObject->FileId.Vnode,
 194                               pCurrentObject->FileId.Unique,
 195                               STATUS_FILE_DELETED);
 196
 197                 try_return( ntStatus = STATUS_FILE_DELETED);
 198             }
 199
 200             if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
 201             {
 202
 203                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 204                               AFS_TRACE_LEVEL_ERROR,
 205                               "AFSLocateNameEntry (FO: %p) Delete pending on %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 206                               FileObject,
 207                               &pDirEntry->NameInformation.FileName,
 208                               pCurrentObject->FileId.Cell,
 209                               pCurrentObject->FileId.Volume,
 210                               pCurrentObject->FileId.Vnode,
 211                               pCurrentObject->FileId.Unique,
 212                               STATUS_DELETE_PENDING);
 213
 214                 try_return( ntStatus = STATUS_DELETE_PENDING);
 215             }
 216
 217             //
 218             // Check if the directory requires verification
 219             //
 220
 221             if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY) &&
 222                 ( pCurrentObject->FileType != AFS_FILE_TYPE_DIRECTORY ||
 223                   !AFSIsEnumerationInProcess( pCurrentObject)))
 224             {
 225
 226                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 227                               AFS_TRACE_LEVEL_VERBOSE,
 228                               "AFSLocateNameEntry (FO: %p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 229                               FileObject,
 230                               &pDirEntry->NameInformation.FileName,
 231                               pCurrentObject->FileId.Cell,
 232                               pCurrentObject->FileId.Volume,
 233                               pCurrentObject->FileId.Vnode,
 234                               pCurrentObject->FileId.Unique);
 235
 236                 //
 237                 // Directory TreeLock should be exclusively held
 238                 //
 239
 240                 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
 241                                 TRUE);
 242
 243                 ntStatus = AFSVerifyEntry( AuthGroup,
 244                                            pDirEntry);
 245
 246                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 247
 248                 if( !NT_SUCCESS( ntStatus))
 249                 {
 250
 251                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 252                                   AFS_TRACE_LEVEL_ERROR,
 253                                   "AFSLocateNameEntry (FO: %p) Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 254                                   FileObject,
 255                                   &pDirEntry->NameInformation.FileName,
 256                                   pCurrentObject->FileId.Cell,
 257                                   pCurrentObject->FileId.Volume,
 258                                   pCurrentObject->FileId.Vnode,
 259                                   pCurrentObject->FileId.Unique,
 260                                   ntStatus);
 261
 262                     try_return( ntStatus);
 263                 }
 264             }
 265
 266             //
 267             // Ensure the parent node has been evaluated, if not then go do it now
 268             //
 269
 270             if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) ||
 271                 pCurrentObject->FileType == AFS_FILE_TYPE_UNKNOWN)
 272             {
 273
 274                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 275                               AFS_TRACE_LEVEL_VERBOSE,
 276                               "AFSLocateNameEntry (FO: %p) Evaluating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 277                               FileObject,
 278                               &pDirEntry->NameInformation.FileName,
 279                               pCurrentObject->FileId.Cell,
 280                               pCurrentObject->FileId.Volume,
 281                               pCurrentObject->FileId.Vnode,
 282                               pCurrentObject->FileId.Unique);
 283
 284                 ntStatus = AFSEvaluateNode( AuthGroup,
 285                                             pDirEntry);
 286
 287                 if( !NT_SUCCESS( ntStatus))
 288                 {
 289
 290                     if ( ntStatus == STATUS_NOT_A_DIRECTORY)
 291                     {
 292
 293                         if ( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
 294                         {
 295
 296                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 297                                           AFS_TRACE_LEVEL_ERROR,
 298                                           "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT NULL Status %08lX\n",
 299                                           FileObject,
 300                                           &pDirEntry->NameInformation.FileName,
 301                                           pCurrentObject->FileId.Cell,
 302                                           pCurrentObject->FileId.Volume,
 303                                           pCurrentObject->FileId.Vnode,
 304                                           pCurrentObject->FileId.Unique,
 305                                           ntStatus);
 306                         }
 307                         else
 308                         {
 309
 310                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 311                                           AFS_TRACE_LEVEL_ERROR,
 312                                           "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 313                                           FileObject,
 314                                           &pDirEntry->NameInformation.FileName,
 315                                           pCurrentObject->FileId.Cell,
 316                                           pCurrentObject->FileId.Volume,
 317                                           pCurrentObject->FileId.Vnode,
 318                                           pCurrentObject->FileId.Unique,
 319                                           pCurrentObject->ParentFileId.Cell,
 320                                           pCurrentObject->ParentFileId.Volume,
 321                                           pCurrentObject->ParentFileId.Vnode,
 322                                           pCurrentObject->ParentFileId.Unique,
 323                                           ntStatus);
 324                         }
 325                     }
 326                     else
 327                     {
 328                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 329                                       AFS_TRACE_LEVEL_ERROR,
 330                                       "AFSLocateNameEntry (FO: %p) Failed to evaluate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 331                                       FileObject,
 332                                       &pDirEntry->NameInformation.FileName,
 333                                       pCurrentObject->FileId.Cell,
 334                                       pCurrentObject->FileId.Volume,
 335                                       pCurrentObject->FileId.Vnode,
 336                                       pCurrentObject->FileId.Unique,
 337                                       ntStatus);
 338                     }
 339
 340                     try_return( ntStatus);
 341                 }
 342
 343                 ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
 344             }
 345
 346             //
 347             // If this is a mount point or symlink then go get the real directory node
 348             //
 349
 350             switch( pCurrentObject->FileType)
 351             {
 352
 353                 case AFS_FILE_TYPE_SYMLINK:
 354                 {
 355
 356                     UNICODE_STRING uniTempName;
 357                     WCHAR *pTmpBuffer = NULL;
 358                     LONG lLinkCount = 0;
 359
 360                     //
 361                     // Check if the flag is set to NOT evaluate a symlink
 362                     // and we are done with the parsing
 363                     //
 364
 365                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL) &&
 366                         uniRemainingPath.Length == 0)
 367                     {
 368
 369                         //
 370                         // Pass back the directory entries
 371                         //
 372
 373                         *OutParentDirectoryCB = pParentDirEntry;
 374
 375                         *OutDirectoryCB = pDirEntry;
 376
 377                         *OutVolumeCB = pCurrentVolume;
 378
 379                         *OutVolumeReferenceReason = VolumeReferenceReason;
 380
 381                         bReleaseCurrentVolume = FALSE;
 382
 383                         *RootPathName = uniFullPathName;
 384
 385                         try_return( ntStatus);
 386                     }
 387
 388                     AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
 389                                     TRUE);
 390
 391                     AFSAcquireExcl( &pDirEntry->NonPaged->Lock,
 392                                     TRUE);
 393
 394                     if( pDirEntry->NameInformation.TargetName.Length == 0)
 395                     {
 396
 397                         //
 398                         // We'll reset the DV to ensure we validate the metadata content
 399                         //
 400
 401                         pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
 402
 403                         SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
 404
 405                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 406                                       AFS_TRACE_LEVEL_VERBOSE,
 407                                       "AFSLocateNameEntry (FO: %p) Verifying symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 408                                       FileObject,
 409                                       &pDirEntry->NameInformation.FileName,
 410                                       pCurrentObject->FileId.Cell,
 411                                       pCurrentObject->FileId.Volume,
 412                                       pCurrentObject->FileId.Vnode,
 413                                       pCurrentObject->FileId.Unique);
 414
 415                         //
 416                         // Directory TreeLock should be exclusively held
 417                         //
 418
 419                         ntStatus = AFSVerifyEntry( AuthGroup,
 420                                                    pDirEntry);
 421
 422                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 423
 424                         if( !NT_SUCCESS( ntStatus))
 425                         {
 426
 427                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 428                                           AFS_TRACE_LEVEL_ERROR,
 429                                           "AFSLocateNameEntry (FO: %p) Failed to verify symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 430                                           FileObject,
 431                                           &pDirEntry->NameInformation.FileName,
 432                                           pCurrentObject->FileId.Cell,
 433                                           pCurrentObject->FileId.Volume,
 434                                           pCurrentObject->FileId.Vnode,
 435                                           pCurrentObject->FileId.Unique,
 436                                           ntStatus);
 437
 438                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 439
 440                             try_return( ntStatus);
 441                         }
 442
 443                         //
 444                         // If the type changed then reprocess this entry
 445                         //
 446
 447                         if( pCurrentObject->FileType != AFS_FILE_TYPE_SYMLINK)
 448                         {
 449
 450                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 451
 452                             continue;
 453                         }
 454                     }
 455                     else
 456                     {
 457
 458                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 459                     }
 460
 461                     //
 462                     // If we were given a zero length target name then deny access to the entry
 463                     //
 464
 465                     if( pDirEntry->NameInformation.TargetName.Length == 0)
 466                     {
 467
 468                         ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
 469
 470                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 471                                       AFS_TRACE_LEVEL_ERROR,
 472                                       "AFSLocateNameEntry (FO: %p) Failed to retrieve target name for symlink %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 473                                       FileObject,
 474                                       &pDirEntry->NameInformation.FileName,
 475                                       pCurrentObject->FileId.Cell,
 476                                       pCurrentObject->FileId.Volume,
 477                                       pCurrentObject->FileId.Vnode,
 478                                       pCurrentObject->FileId.Unique,
 479                                       ntStatus);
 480
 481                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 482
 483                         try_return( ntStatus);
 484                     }
 485
 486                     if( AFSIsRelativeName( &pDirEntry->NameInformation.TargetName))
 487                     {
 488
 489                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 490                                       AFS_TRACE_LEVEL_VERBOSE,
 491                                       "AFSLocateNameEntry (FO: %p) Processing relative symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 492                                       FileObject,
 493                                       &pDirEntry->NameInformation.TargetName,
 494                                       &pDirEntry->NameInformation.FileName,
 495                                       pCurrentObject->FileId.Cell,
 496                                       pCurrentObject->FileId.Volume,
 497                                       pCurrentObject->FileId.Vnode,
 498                                       pCurrentObject->FileId.Unique);
 499
 500                         //
 501                         // We'll substitute this name into the current process name
 502                         // starting at where we sit in the path
 503                         //
 504
 505                         uniTempName.Length = 0;
 506                         uniTempName.MaximumLength = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer) +
 507                                                                     pDirEntry->NameInformation.TargetName.Length +
 508                                                                     sizeof( WCHAR) +
 509                                                                     uniRemainingPath.Length;
 510
 511                         uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 512                                                                                 uniTempName.MaximumLength,
 513                                                                                 AFS_NAME_BUFFER_ONE_TAG);
 514
 515                         if( uniTempName.Buffer == NULL)
 516                         {
 517
 518                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 519
 520                             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 521                         }
 522
 523                         //
 524                         // We have so first copy in the portion up to the component
 525                         // name
 526                         //
 527
 528                         RtlCopyMemory( uniTempName.Buffer,
 529                                        uniFullPathName.Buffer,
 530                                        (ULONG)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer));
 531
 532                         uniTempName.Length = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer);
 533
 534                         if( bAllocatedSymLinkBuffer ||
 535                             bSubstitutedName)
 536                         {
 537
 538                             pTmpBuffer = uniFullPathName.Buffer;
 539                         }
 540
 541                         bAllocatedSymLinkBuffer = TRUE;
 542
 543                         //
 544                         // Have we parsed this name yet? Better have at least once ...
 545                         //
 546
 547                         if( uniComponentName.Length == 0)
 548                         {
 549                             ASSERT( FALSE);
 550                         }
 551
 552                         //
 553                         // Copy in the target name ...
 554                         //
 555
 556                         RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 557                                        pDirEntry->NameInformation.TargetName.Buffer,
 558                                        pDirEntry->NameInformation.TargetName.Length);
 559
 560                         uniPathName.Buffer = &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)];
 561
 562                         uniPathName.Length += pDirEntry->NameInformation.TargetName.Length;
 563                         uniPathName.MaximumLength = uniTempName.MaximumLength;
 564
 565                         uniTempName.Length += pDirEntry->NameInformation.TargetName.Length;
 566
 567                         //
 568                         // And now any remaining portion of the name
 569                         //
 570
 571                         if( uniRemainingPath.Length > 0)
 572                         {
 573
 574                             if( uniRemainingPath.Buffer[ 0] != L'\\')
 575                             {
 576
 577                                 uniRemainingPath.Buffer--;
 578                                 uniRemainingPath.Length += sizeof( WCHAR);
 579
 580                                 uniPathName.Length += sizeof( WCHAR);
 581                             }
 582
 583                             RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 584                                            uniRemainingPath.Buffer,
 585                                            uniRemainingPath.Length);
 586
 587                             uniTempName.Length += uniRemainingPath.Length;
 588                         }
 589
 590                         uniFullPathName = uniTempName;
 591
 592                         if( pTmpBuffer != NULL)
 593                         {
 594
 595                             AFSExFreePoolWithTag( pTmpBuffer, 0);
 596                         }
 597
 598                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 599
 600                         //
 601                         // Dereference the current entry ..
 602                         //
 603
 604                         lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 605
 606                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 607                                       AFS_TRACE_LEVEL_VERBOSE,
 608                                       "AFSLocateNameEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
 609                                       &pDirEntry->NameInformation.FileName,
 610                                       pDirEntry,
 611                                       NULL,
 612                                       lCount);
 613
 614                         ASSERT( lCount >= 0);
 615
 616                         //
 617                         // OK, need to back up one entry for the correct parent since the current
 618                         // entry we are on is the symlink itself
 619                         //
 620
 621                         pDirEntry = AFSBackupEntry( pNameArray);
 622
 623                         //
 624                         // Increment our reference on this dir entry
 625                         //
 626
 627                         lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 628
 629                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 630                                       AFS_TRACE_LEVEL_VERBOSE,
 631                                       "AFSLocateNameEntry Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
 632                                       &pDirEntry->NameInformation.FileName,
 633                                       pDirEntry,
 634                                       NULL,
 635                                       lCount);
 636
 637                         if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
 638                         {
 639
 640                             pParentDirEntry = NULL;
 641                         }
 642                         else
 643                         {
 644
 645                             pParentDirEntry = AFSGetParentEntry( pNameArray);
 646
 647                             ASSERT( pParentDirEntry != pDirEntry);
 648                         }
 649                     }
 650                     else
 651                     {
 652
 653                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 654                                       AFS_TRACE_LEVEL_VERBOSE,
 655                                       "AFSLocateNameEntry (FO: %p) Processing absolute symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 656                                       FileObject,
 657                                       &pDirEntry->NameInformation.TargetName,
 658                                       &pDirEntry->NameInformation.FileName,
 659                                       pCurrentObject->FileId.Cell,
 660                                       pCurrentObject->FileId.Volume,
 661                                       pCurrentObject->FileId.Vnode,
 662                                       pCurrentObject->FileId.Unique);
 663
 664                         if ( !AFSIsAbsoluteAFSName( &pDirEntry->NameInformation.TargetName))
 665                         {
 666
 667                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 668                                           AFS_TRACE_LEVEL_ERROR,
 669                                           "AFSLocateNameEntry Name %wZ contains invalid server name\n",
 670                                           &pDirEntry->NameInformation.TargetName);
 671
 672                             //
 673                             // The correct response would be STATUS_OBJECT_PATH_INVALID
 674                             // but that prevents cmd.exe from performing a recursive
 675                             // directory enumeration when opening a directory entry
 676                             // that represents a symlink to an invalid path is discovered.
 677                             //
 678
 679                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 680
 681                             try_return( ntStatus = STATUS_OBJECT_PATH_NOT_FOUND);
 682                         }
 683
 684                         //
 685                         // We'll substitute this name into the current process name
 686                         // starting at where we sit in the path
 687                         //
 688
 689                         uniTempName.Length = 0;
 690                         uniTempName.MaximumLength = pDirEntry->NameInformation.TargetName.Length +
 691                                                                     sizeof( WCHAR) +
 692                                                                     uniRemainingPath.Length;
 693
 694                         uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 695                                                                                 uniTempName.MaximumLength,
 696                                                                                 AFS_NAME_BUFFER_TWO_TAG);
 697
 698                         if( uniTempName.Buffer == NULL)
 699                         {
 700
 701                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 702
 703                             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 704                         }
 705
 706                         if( bAllocatedSymLinkBuffer ||
 707                             bSubstitutedName)
 708                         {
 709
 710                             pTmpBuffer = uniFullPathName.Buffer;
 711                         }
 712
 713                         bAllocatedSymLinkBuffer = TRUE;
 714
 715                         //
 716                         // Have we parsed this name yet? Better have at least once ...
 717                         //
 718
 719                         if( uniComponentName.Length == 0)
 720                         {
 721                             ASSERT( FALSE);
 722                         }
 723
 724                         //
 725                         // Copy in the target name ...
 726                         //
 727
 728                         RtlCopyMemory( uniTempName.Buffer,
 729                                        &pDirEntry->NameInformation.TargetName.Buffer[ AFSMountRootName.Length/sizeof( WCHAR)],
 730                                        pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length);
 731
 732                         uniTempName.Length = pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length;
 733
 734                         //
 735                         // And now any remaining portion of the name
 736                         //
 737
 738                         if( uniRemainingPath.Length > 0)
 739                         {
 740
 741                             if( uniRemainingPath.Buffer[ 0] != L'\\')
 742                             {
 743
 744                                 uniRemainingPath.Buffer--;
 745                                 uniRemainingPath.Length += sizeof( WCHAR);
 746                             }
 747
 748                             RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 749                                            uniRemainingPath.Buffer,
 750                                            uniRemainingPath.Length);
 751
 752                             uniTempName.Length += uniRemainingPath.Length;
 753                         }
 754
 755                         uniFullPathName = uniTempName;
 756
 757                         uniPathName = uniTempName;
 758
 759                         if( pTmpBuffer != NULL)
 760                         {
 761
 762                             AFSExFreePoolWithTag( pTmpBuffer, 0);
 763                         }
 764
 765                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 766
 767                         //
 768                         // If our current volume is not the global root then make it so ...
 769                         //
 770
 771                         if( pCurrentVolume != AFSGlobalRoot)
 772                         {
 773
 774                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 775                                           AFS_TRACE_LEVEL_VERBOSE,
 776                                           "AFSLocateNameEntry (FO: %p) Current volume not global, resetting for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 777                                           FileObject,
 778                                           &pDirEntry->NameInformation.FileName,
 779                                           pCurrentObject->FileId.Cell,
 780                                           pCurrentObject->FileId.Volume,
 781                                           pCurrentObject->FileId.Vnode,
 782                                           pCurrentObject->FileId.Unique);
 783
 784                             lCount = AFSVolumeDecrement( pCurrentVolume,
 785                                                          VolumeReferenceReason);
 786
 787                             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 788                                           AFS_TRACE_LEVEL_VERBOSE,
 789                                           "AFSLocateNameEntry Decrement count on volume %p Reason %u Cnt %d\n",
 790                                           pCurrentVolume,
 791                                           VolumeReferenceReason,
 792                                           lCount);
 793
 794                             pCurrentVolume = AFSGlobalRoot;
 795
 796                             VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
 797
 798                             lCount = AFSVolumeIncrement( pCurrentVolume,
 799                                                          VolumeReferenceReason);
 800
 801                             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 802                                           AFS_TRACE_LEVEL_VERBOSE,
 803                                           "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
 804                                           pCurrentVolume,
 805                                           VolumeReferenceReason,
 806                                           lCount);
 807                         }
 808
 809                         //
 810                         // Dereference our current dir entry
 811                         //
 812
 813                         lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 814
 815                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 816                                       AFS_TRACE_LEVEL_VERBOSE,
 817                                       "AFSLocateNameEntry Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
 818                                       &pDirEntry->NameInformation.FileName,
 819                                       pDirEntry,
 820                                       NULL,
 821                                       lCount);
 822
 823                         ASSERT( lCount >= 0);
 824
 825                         pDirEntry = pCurrentVolume->DirectoryCB;
 826
 827                         //
 828                         // Reference the new dir entry
 829                         //
 830
 831                         lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 832
 833                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 834                                       AFS_TRACE_LEVEL_VERBOSE,
 835                                       "AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
 836                                       &pDirEntry->NameInformation.FileName,
 837                                       pDirEntry,
 838                                       NULL,
 839                                       lCount);
 840
 841                         //
 842                         // Reset the name array
 843                         // Persist the link count in the name array
 844                         //
 845
 846                         lLinkCount = pNameArray->LinkCount;
 847
 848                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 849                                       AFS_TRACE_LEVEL_VERBOSE,
 850                                       "AFSLocateNameEntry (FO: %p) Resetting name array for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 851                                       FileObject,
 852                                       &pDirEntry->NameInformation.FileName,
 853                                       pCurrentObject->FileId.Cell,
 854                                       pCurrentObject->FileId.Volume,
 855                                       pCurrentObject->FileId.Vnode,
 856                                       pCurrentObject->FileId.Unique);
 857
 858                         AFSResetNameArray( pNameArray,
 859                                            pDirEntry);
 860
 861                         pNameArray->LinkCount = lLinkCount;
 862
 863                         pParentDirEntry = NULL;
 864                     }
 865
 866                     //
 867                     // Increment our link count
 868                     //
 869
 870                     lCount = InterlockedIncrement( &pNameArray->LinkCount);
 871
 872                     continue;
 873                 }
 874
 875                 case AFS_FILE_TYPE_MOUNTPOINT:
 876                 {
 877
 878                     //
 879                     // Check if the flag is set to NOT evaluate a mount point
 880                     // and we are done with the parsing
 881                     //
 882
 883                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL) &&
 884                         uniRemainingPath.Length == 0)
 885                     {
 886
 887                         //
 888                         // Pass back the directory entries
 889                         //
 890
 891                         *OutParentDirectoryCB = pParentDirEntry;
 892
 893                         *OutDirectoryCB = pDirEntry;
 894
 895                         *OutVolumeCB = pCurrentVolume;
 896
 897                         *OutVolumeReferenceReason = VolumeReferenceReason;
 898
 899                         bReleaseCurrentVolume = FALSE;
 900
 901                         *RootPathName = uniFullPathName;
 902
 903                         try_return( ntStatus);
 904                     }
 905
 906                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 907                                   AFS_TRACE_LEVEL_VERBOSE,
 908                                   "AFSLocateNameEntry (FO: %p) Building MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 909                                   FileObject,
 910                                   &pDirEntry->NameInformation.FileName,
 911                                   pCurrentObject->FileId.Cell,
 912                                   pCurrentObject->FileId.Volume,
 913                                   pCurrentObject->FileId.Vnode,
 914                                   pCurrentObject->FileId.Unique);
 915
 916                     //
 917                     // Go retrieve the target entry for this node
 918                     // Release the current volume cb entry since we would
 919                     // have lock inversion in the following call
 920                     // Also decrement the ref count on the volume
 921                     //
 922
 923                     ntStatus = AFSBuildMountPointTarget( AuthGroup,
 924                                                          pDirEntry,
 925                                                          &pTargetVolume);
 926
 927                     if( !NT_SUCCESS( ntStatus))
 928                     {
 929
 930                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 931                                       AFS_TRACE_LEVEL_ERROR,
 932                                       "AFSLocateNameEntry (FO: %p) Failed to build MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 933                                       FileObject,
 934                                       &pDirEntry->NameInformation.FileName,
 935                                       pCurrentObject->FileId.Cell,
 936                                       pCurrentObject->FileId.Volume,
 937                                       pCurrentObject->FileId.Vnode,
 938                                       pCurrentObject->FileId.Unique,
 939                                       ntStatus);
 940
 941                         try_return( ntStatus);
 942                     }
 943
 944                     ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
 945
 946                     lCount = AFSVolumeDecrement( pCurrentVolume,
 947                                                  VolumeReferenceReason);
 948
 949                     AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 950                                   AFS_TRACE_LEVEL_VERBOSE,
 951                                   "AFSLocateNameEntry Decrement2 count on volume %p Reason %u Cnt %d\n",
 952                                   pCurrentVolume,
 953                                   VolumeReferenceReason,
 954                                   lCount);
 955
 956                     pCurrentVolume = pTargetVolume;
 957
 958                     pTargetVolume = NULL;
 959
 960                     ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
 961
 962                     VolumeReferenceReason = AFS_VOLUME_REFERENCE_MOUNTPT;
 963
 964                     //
 965                     // We want to restart processing here on the new parent ...
 966                     // Deref and ref count the entries
 967                     //
 968
 969                     lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 970
 971                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 972                                   AFS_TRACE_LEVEL_VERBOSE,
 973                                   "AFSLocateNameEntry Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
 974                                   &pDirEntry->NameInformation.FileName,
 975                                   pDirEntry,
 976                                   NULL,
 977                                   lCount);
 978
 979                     ASSERT( lCount >= 0);
 980
 981                     pDirEntry = pCurrentVolume->DirectoryCB;
 982
 983                     lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 984
 985                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 986                                   AFS_TRACE_LEVEL_VERBOSE,
 987                                   "AFSLocateNameEntry Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
 988                                   &pDirEntry->NameInformation.FileName,
 989                                   pDirEntry,
 990                                   NULL,
 991                                   lCount);
 992
 993                     //
 994                     // The name array stores both the mount point and the target.
 995                     // Insert the target.
 996                     //
 997
 998                     AFSInsertNextElement( pNameArray,
 999                                           pDirEntry);
1000
1001                     pParentDirEntry = NULL;
1002
1003                     //
1004                     // Increment our link count
1005                     //
1006
1007                     lCount = InterlockedIncrement( &pNameArray->LinkCount);
1008
1009                     continue;
1010                 }
1011
1012                 case AFS_FILE_TYPE_DFSLINK:
1013                 {
1014
1015                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL))
1016                     {
1017
1018                         //
1019                         // Pass back the directory entries
1020                         //
1021
1022                         *OutParentDirectoryCB = pParentDirEntry;
1023
1024                         *OutDirectoryCB = pDirEntry;
1025
1026                         *OutVolumeCB = pCurrentVolume;
1027
1028                         *OutVolumeReferenceReason = VolumeReferenceReason;
1029
1030                         bReleaseCurrentVolume = FALSE;
1031
1032                         *RootPathName = uniFullPathName;
1033
1034                         try_return( ntStatus);
1035                     }
1036
1037                     //
1038                     // This is a DFS link so we need to update the file name and return STATUS_REPARSE to the
1039                     // system for it to reevaluate it
1040                     //
1041
1042                     if( FileObject != NULL)
1043                     {
1044
1045                         ntStatus = AFSProcessDFSLink( pDirEntry,
1046                                                       FileObject,
1047                                                       &uniRemainingPath,
1048                                                       AuthGroup);
1049                     }
1050                     else
1051                     {
1052
1053                         //
1054                         // This is where we have been re-entered from an NP evaluation call via the BuildBranch()
1055                         // routine.
1056                         //
1057
1058                         ntStatus = STATUS_INVALID_PARAMETER;
1059                     }
1060
1061                     if( ntStatus != STATUS_SUCCESS &&
1062                         ntStatus != STATUS_REPARSE)
1063                     {
1064
1065                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1066                                       AFS_TRACE_LEVEL_ERROR,
1067                                       "AFSLocateNameEntry (FO: %p) Failed to process DFSLink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1068                                       FileObject,
1069                                       &pDirEntry->NameInformation.FileName,
1070                                       pCurrentObject->FileId.Cell,
1071                                       pCurrentObject->FileId.Volume,
1072                                       pCurrentObject->FileId.Vnode,
1073                                       pCurrentObject->FileId.Unique,
1074                                       ntStatus);
1075                     }
1076
1077                     try_return( ntStatus);
1078                 }
1079
1080                 case AFS_FILE_TYPE_UNKNOWN:
1081                 case AFS_FILE_TYPE_INVALID:
1082                 {
1083
1084                     //
1085                     // Something was not processed ...
1086                     //
1087
1088                     try_return( ntStatus = STATUS_ACCESS_DENIED);
1089                 }
1090
1091             }   /* end of switch */
1092
1093             //
1094             // If the parent is not initialized then do it now
1095             //
1096
1097             if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
1098                 !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1099             {
1100
1101                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1102                               AFS_TRACE_LEVEL_VERBOSE,
1103                               "AFSLocateNameEntry (FO: %p) Enumerating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1104                               FileObject,
1105                               &pDirEntry->NameInformation.FileName,
1106                               pCurrentObject->FileId.Cell,
1107                               pCurrentObject->FileId.Volume,
1108                               pCurrentObject->FileId.Vnode,
1109                               pCurrentObject->FileId.Unique);
1110
1111                 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
1112                                 TRUE);
1113
1114                 if( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1115                 {
1116
1117                     ntStatus = AFSEnumerateDirectory( AuthGroup,
1118                                                       pCurrentObject,
1119                                                       TRUE);
1120
1121                     if( !NT_SUCCESS( ntStatus))
1122                     {
1123
1124                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1125
1126                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1127                                       AFS_TRACE_LEVEL_ERROR,
1128                                       "AFSLocateNameEntry (FO: %p) Failed to enumerate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1129                                       FileObject,
1130                                       &pDirEntry->NameInformation.FileName,
1131                                       pCurrentObject->FileId.Cell,
1132                                       pCurrentObject->FileId.Volume,
1133                                       pCurrentObject->FileId.Vnode,
1134                                       pCurrentObject->FileId.Unique,
1135                                       ntStatus);
1136
1137                         try_return( ntStatus);
1138                     }
1139
1140                     SetFlag( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1141                 }
1142
1143                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1144             }
1145             else if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
1146             {
1147
1148                 if( uniPathName.Length > 0)
1149                 {
1150
1151                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1152                                   AFS_TRACE_LEVEL_ERROR,
1153                                   "AFSLocateNameEntry (FO: %p) Encountered file node %wZ FID %08lX-%08lX-%08lX-%08lX in path processing\n",
1154                                   FileObject,
1155                                   &pDirEntry->NameInformation.FileName,
1156                                   pCurrentObject->FileId.Cell,
1157                                   pCurrentObject->FileId.Volume,
1158                                   pCurrentObject->FileId.Vnode,
1159                                   pCurrentObject->FileId.Unique);
1160
1161                     // The proper error code to return would be STATUS_OBJECT_PATH_INVALID because
1162                     // one of the components of the path is not a directory.  However, returning
1163                     // that error prevents IIS 7 and 7.5 from being able to serve data out of AFS.
1164                     // Instead IIS insists on treating the target file as if it is a directory containing
1165                     // a potential web.config file.  NTFS and LanMan return STATUS_OBJECT_PATH_NOT_FOUND.
1166                     // AFS will follow suit.
1167
1168                     ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1169                 }
1170                 else
1171                 {
1172
1173                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1174                                   AFS_TRACE_LEVEL_VERBOSE,
1175                                   "AFSLocateNameEntry (FO: %p) Returning file %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1176                                   FileObject,
1177                                   &pDirEntry->NameInformation.FileName,
1178                                   pCurrentObject->FileId.Cell,
1179                                   pCurrentObject->FileId.Volume,
1180                                   pCurrentObject->FileId.Vnode,
1181                                   pCurrentObject->FileId.Unique);
1182
1183                     //
1184                     // Pass back the directory entries
1185                     //
1186
1187                     *OutParentDirectoryCB = pParentDirEntry;
1188
1189                     *OutDirectoryCB = pDirEntry;
1190
1191                     *OutVolumeCB = pCurrentVolume;
1192
1193                     *OutVolumeReferenceReason = VolumeReferenceReason;
1194
1195                     bReleaseCurrentVolume = FALSE;
1196
1197                     *RootPathName = uniFullPathName;
1198                 }
1199
1200                 try_return( ntStatus);
1201             }
1202
1203             //
1204             // If we are at the end of the processing, set our returned information and get out
1205             //
1206
1207             if( uniPathName.Length == 0)
1208             {
1209
1210                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1211                               AFS_TRACE_LEVEL_VERBOSE,
1212                               "AFSLocateNameEntry (FO: %p) Completed processing returning %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1213                               FileObject,
1214                               &pDirEntry->NameInformation.FileName,
1215                               pCurrentObject->FileId.Cell,
1216                               pCurrentObject->FileId.Volume,
1217                               pCurrentObject->FileId.Vnode,
1218                               pCurrentObject->FileId.Unique);
1219
1220                 //
1221                 // Pass back the directory entries
1222                 //
1223
1224                 *OutParentDirectoryCB = pParentDirEntry;
1225
1226                 *OutDirectoryCB = pDirEntry;
1227
1228                 *OutVolumeCB = pCurrentVolume;
1229
1230                 *OutVolumeReferenceReason = VolumeReferenceReason;
1231
1232                 bReleaseCurrentVolume = FALSE;
1233
1234                 *RootPathName = uniFullPathName;
1235
1236                 try_return( ntStatus);
1237             }
1238
1239             //
1240             // We may have returned to the top of the while( TRUE)
1241             //
1242             if( bSubstituteName &&
1243                 uniSearchName.Buffer != NULL)
1244             {
1245
1246                 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1247
1248                 bSubstituteName = FALSE;
1249
1250                 uniSearchName.Length = uniSearchName.MaximumLength = 0;
1251                 uniSearchName.Buffer = NULL;
1252             }
1253
1254             ulSubstituteIndex = 1;
1255
1256             ntStatus = STATUS_SUCCESS;
1257
1258             //
1259             // Get the next component name
1260             //
1261
1262             FsRtlDissectName( uniPathName,
1263                               &uniComponentName,
1264                               &uniRemainingPath);
1265
1266             //
1267             // Check for the . and .. in the path
1268             //
1269
1270             if( RtlCompareUnicodeString( &uniComponentName,
1271                                          &uniNoOpName,
1272                                          TRUE) == 0)
1273             {
1274
1275                 uniPathName = uniRemainingPath;
1276
1277                 continue;
1278             }
1279
1280             if( RtlCompareUnicodeString( &uniComponentName,
1281                                          &uniRelativeName,
1282                                          TRUE) == 0)
1283             {
1284
1285                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1286                               AFS_TRACE_LEVEL_VERBOSE,
1287                               "AFSLocateNameEntry (FO: %p) Backing up entry from %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1288                               FileObject,
1289                               &pDirEntry->NameInformation.FileName,
1290                               pCurrentObject->FileId.Cell,
1291                               pCurrentObject->FileId.Volume,
1292                               pCurrentObject->FileId.Vnode,
1293                               pCurrentObject->FileId.Unique);
1294
1295                 //
1296                 // Need to back up one entry in the name array
1297                 //
1298                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1299
1300                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1301                               AFS_TRACE_LEVEL_VERBOSE,
1302                               "AFSLocateNameEntry Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
1303                               &pDirEntry->NameInformation.FileName,
1304                               pDirEntry,
1305                               NULL,
1306                               lCount);
1307
1308                 ASSERT( lCount >= 0);
1309
1310                 pDirEntry = AFSBackupEntry( NameArray);
1311
1312                 if( pDirEntry == NULL)
1313                 {
1314
1315                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1316                                   AFS_TRACE_LEVEL_ERROR,
1317                                   "AFSLocateNameEntry AFSBackupEntry failed\n");
1318
1319                     try_return(ntStatus = STATUS_OBJECT_PATH_INVALID);
1320                 }
1321
1322                 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1323
1324                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1325                               AFS_TRACE_LEVEL_VERBOSE,
1326                               "AFSLocateNameEntry Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
1327                               &pDirEntry->NameInformation.FileName,
1328                               pDirEntry,
1329                               NULL,
1330                               lCount);
1331
1332                 if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
1333                 {
1334
1335                     pParentDirEntry = NULL;
1336                 }
1337                 else
1338                 {
1339
1340                     pParentDirEntry = AFSGetParentEntry( pNameArray);
1341
1342                     ASSERT( pParentDirEntry != pDirEntry);
1343                 }
1344
1345                 uniPathName = uniRemainingPath;
1346
1347                 continue;
1348             }
1349
1350             //
1351             // Update our pointers
1352             //
1353
1354             pParentDirEntry = pDirEntry;
1355
1356             pDirEntry = NULL;
1357
1358             uniSearchName = uniComponentName;
1359
1360             while( pDirEntry == NULL)
1361             {
1362
1363                 //
1364                 // If the SearchName contains @SYS then we perform the substitution.
1365                 // If there is no substitution we give up.
1366                 //
1367
1368                 if( !bSubstituteName &&
1369                     FsRtlIsNameInExpression( &uniSysName,
1370                                              &uniSearchName,
1371                                              TRUE,
1372                                              NULL))
1373                 {
1374
1375                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1376                                   AFS_TRACE_LEVEL_VERBOSE_2,
1377                                   "AFSLocateNameEntry (FO: %p) Processing @SYS substitution for %wZ Index %08lX\n",
1378                                   FileObject,
1379                                   &uniComponentName,
1380                                   ulSubstituteIndex);
1381
1382                     ntStatus = AFSSubstituteSysName( &uniComponentName,
1383                                                      &uniSearchName,
1384                                                      ulSubstituteIndex);
1385
1386                     if ( NT_SUCCESS( ntStatus))
1387                     {
1388
1389                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1390                                       AFS_TRACE_LEVEL_VERBOSE_2,
1391                                       "AFSLocateNameEntry (FO: %p) Located substitution %wZ for %wZ Index %08lX\n",
1392                                       FileObject,
1393                                       &uniSearchName,
1394                                       &uniComponentName,
1395                                       ulSubstituteIndex);
1396
1397                         //
1398                         // Go reparse the name again
1399                         //
1400
1401                         bSubstituteName = TRUE;
1402
1403                         ulSubstituteIndex++; // For the next entry, if needed
1404
1405                         continue;   // while( pDirEntry == NULL)
1406                     }
1407                     else
1408                     {
1409
1410                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1411                                       AFS_TRACE_LEVEL_ERROR,
1412                                       "AFSLocateNameEntry (FO: %p) Failed to locate substitute string for %wZ Index %08lX Status %08lX\n",
1413                                       FileObject,
1414                                       &uniComponentName,
1415                                       ulSubstituteIndex,
1416                                       ntStatus);
1417
1418                         if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
1419                         {
1420
1421                             //
1422                             // Pass back the directory entries
1423                             //
1424
1425                             *OutParentDirectoryCB = pParentDirEntry;
1426
1427                             *OutDirectoryCB = NULL;
1428
1429                             *OutVolumeCB = pCurrentVolume;
1430
1431                             *OutVolumeReferenceReason = VolumeReferenceReason;
1432
1433                             bReleaseCurrentVolume = FALSE;
1434
1435                             if( ComponentName != NULL)
1436                             {
1437
1438                                 *ComponentName = uniComponentName;
1439                             }
1440
1441                             *RootPathName = uniFullPathName;
1442                         }
1443
1444                         //
1445                         // We can't possibly have a pDirEntry since the lookup failed
1446                         //
1447                         try_return( ntStatus);
1448                     }
1449                 }
1450
1451                 //
1452                 // Generate the CRC on the node and perform a case sensitive lookup
1453                 //
1454
1455                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1456                               AFS_TRACE_LEVEL_VERBOSE_2,
1457                               "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case sensitive\n",
1458                               FileObject,
1459                               &uniSearchName);
1460
1461                 ulCRC = AFSGenerateCRC( &uniSearchName,
1462                                         FALSE);
1463
1464                 AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1465                                   TRUE);
1466
1467                 AFSLocateCaseSensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
1468                                                 ulCRC,
1469                                                 &pDirEntry);
1470
1471                 if( pDirEntry == NULL)
1472                 {
1473
1474                     //
1475                     // Missed so perform a case insensitive lookup
1476                     //
1477
1478                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1479                                   AFS_TRACE_LEVEL_VERBOSE_2,
1480                                   "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case insensitive\n",
1481                                   FileObject,
1482                                   &uniSearchName);
1483
1484                     ulCRC = AFSGenerateCRC( &uniSearchName,
1485                                             TRUE);
1486
1487                     AFSLocateCaseInsensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
1488                                                       ulCRC,
1489                                                       &pDirEntry);
1490
1491                     if( pDirEntry == NULL)
1492                     {
1493
1494                         //
1495                         // OK, if this component is a valid short name then try
1496                         // a lookup in the short name tree
1497                         //
1498
1499                         if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
1500                             RtlIsNameLegalDOS8Dot3( &uniSearchName,
1501                                                     NULL,
1502                                                     NULL))
1503                         {
1504
1505                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1506                                           AFS_TRACE_LEVEL_VERBOSE_2,
1507                                           "AFSLocateNameEntry (FO: %p) Searching for entry %wZ short name\n",
1508                                           FileObject,
1509                                           &uniSearchName);
1510
1511                             AFSLocateShortNameDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.ShortNameTree,
1512                                                         ulCRC,
1513                                                         &pDirEntry);
1514                         }
1515
1516                         if ( pDirEntry == NULL &&
1517                              pParentDirEntry->ObjectInformation->VolumeCB == AFSGlobalRoot)
1518                         {
1519
1520                             //
1521                             // Check with the service to see if this is a valid cell name
1522                             // that can be automatically resolved.  Drop the shared TreeLock
1523                             // since AFSCheckCellName must acquire it exclusively.
1524                             //
1525
1526                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1527
1528                             ntStatus = AFSCheckCellName( AuthGroup,
1529                                                          &uniSearchName,
1530                                                          &pDirEntry);
1531
1532                             AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1533                                               TRUE);
1534                         }
1535
1536                         if( pDirEntry == NULL)
1537                         {
1538
1539                             //
1540                             // If we substituted a name then reset our search name and try again
1541                             //
1542
1543                             if( bSubstituteName)
1544                             {
1545
1546                                 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1547
1548                                 uniSearchName = uniComponentName;
1549
1550                                 bSubstituteName = FALSE;
1551
1552                                 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1553
1554                                 continue;       // while( pDirEntry == NULL)
1555                             }
1556
1557                             if( uniRemainingPath.Length > 0)
1558                             {
1559
1560                                 ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1561
1562                                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1563                                               AFS_TRACE_LEVEL_VERBOSE,
1564                                               "AFSLocateNameEntry (FO: %p) Returning path not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1565                                               FileObject,
1566                                               &uniSearchName,
1567                                               pCurrentObject->FileId.Cell,
1568                                               pCurrentObject->FileId.Volume,
1569                                               pCurrentObject->FileId.Vnode,
1570                                               pCurrentObject->FileId.Unique);
1571                             }
1572                             else
1573                             {
1574
1575                                 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
1576
1577                                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1578                                               AFS_TRACE_LEVEL_VERBOSE,
1579                                               "AFSLocateNameEntry (FO: %p) Returning name not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1580                                               FileObject,
1581                                               &uniSearchName,
1582                                               pCurrentObject->FileId.Cell,
1583                                               pCurrentObject->FileId.Volume,
1584                                               pCurrentObject->FileId.Vnode,
1585                                               pCurrentObject->FileId.Unique);
1586
1587                                 //
1588                                 // Pass back the directory entries
1589                                 //
1590
1591                                 *OutParentDirectoryCB = pParentDirEntry;
1592
1593                                 *OutDirectoryCB = NULL;
1594
1595                                 *OutVolumeCB = pCurrentVolume;
1596
1597                                 *OutVolumeReferenceReason = VolumeReferenceReason;
1598
1599                                 bReleaseCurrentVolume = FALSE;
1600
1601                                 if( ComponentName != NULL)
1602                                 {
1603
1604                                     *ComponentName = uniComponentName;
1605                                 }
1606
1607                                 *RootPathName = uniFullPathName;
1608                             }
1609
1610                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1611
1612                             //
1613                             // Node name not found so get out
1614                             //
1615
1616                             try_return( ntStatus);  // while( pDirEntry == NULL)
1617                         }
1618                     }
1619                     else
1620                     {
1621
1622                         //
1623                         // Here we have a match on the case insensitive lookup for the name. If there
1624                         // Is more than one link entry for this node then fail the lookup request
1625                         //
1626
1627                         if( !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD) ||
1628                             pDirEntry->CaseInsensitiveList.fLink != NULL)
1629                         {
1630
1631                             //
1632                             // Increment our dir entry ref count since we will decrement it on exit
1633                             //
1634
1635                             lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1636
1637                             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1638                                           AFS_TRACE_LEVEL_VERBOSE,
1639                                           "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
1640                                           &pDirEntry->NameInformation.FileName,
1641                                           pDirEntry,
1642                                           NULL,
1643                                           lCount);
1644
1645                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1646
1647                             try_return(ntStatus = STATUS_OBJECT_NAME_COLLISION);
1648                         }
1649                     }
1650                 }
1651
1652                 if( pDirEntry != NULL)
1653                 {
1654
1655                     //
1656                     // If the verify flag is set on the parent and the current entry is deleted
1657                     // revalidate the parent and search again.
1658                     //
1659
1660                     if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
1661                         BooleanFlagOn( pParentDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
1662                     {
1663
1664                         AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1665
1666                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1667                                       AFS_TRACE_LEVEL_VERBOSE,
1668                                       "AFSLocateNameEntry (FO: %p) Verifying(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1669                                       FileObject,
1670                                       &pParentDirEntry->NameInformation.FileName,
1671                                       pParentDirEntry->ObjectInformation->FileId.Cell,
1672                                       pParentDirEntry->ObjectInformation->FileId.Volume,
1673                                       pParentDirEntry->ObjectInformation->FileId.Vnode,
1674                                       pParentDirEntry->ObjectInformation->FileId.Unique);
1675
1676                         //
1677                         // Directory TreeLock should be exclusively held
1678                         //
1679
1680                         AFSAcquireExcl( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1681                                         TRUE);
1682
1683                         ntStatus = AFSVerifyEntry( AuthGroup,
1684                                                    pParentDirEntry);
1685
1686                         AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1687
1688                         if( !NT_SUCCESS( ntStatus))
1689                         {
1690
1691                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1692                                           AFS_TRACE_LEVEL_ERROR,
1693                                           "AFSLocateNameEntry (FO: %p) Failed to verify(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1694                                           FileObject,
1695                                           &pParentDirEntry->NameInformation.FileName,
1696                                           pParentDirEntry->ObjectInformation->FileId.Cell,
1697                                           pParentDirEntry->ObjectInformation->FileId.Volume,
1698                                           pParentDirEntry->ObjectInformation->FileId.Vnode,
1699                                           pParentDirEntry->ObjectInformation->FileId.Unique,
1700                                           ntStatus);
1701
1702                             try_return( ntStatus);
1703                         }
1704
1705                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1706                                       AFS_TRACE_LEVEL_VERBOSE,
1707                                       "AFSLocateNameEntry (FO: %p) Reprocessing component %wZ in parent %wZ\n",
1708                                       FileObject,
1709                                       &uniSearchName,
1710                                       &pParentDirEntry->NameInformation.FileName);
1711
1712
1713                         pDirEntry = NULL;
1714
1715                         continue;
1716                     }
1717
1718                     //
1719                     // Increment our dir entry ref count
1720                     //
1721
1722                     lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1723
1724                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1725                                   AFS_TRACE_LEVEL_VERBOSE,
1726                                   "AFSLocateNameEntry Increment6 count on %wZ DE %p Ccb %p Cnt %d\n",
1727                                   &pDirEntry->NameInformation.FileName,
1728                                   pDirEntry,
1729                                   NULL,
1730                                   lCount);
1731                 }
1732
1733                 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1734
1735             } // End while( pDirEntry == NULL)
1736
1737             //
1738             // If we have a dirEntry for this component, perform some basic validation on it
1739             //
1740
1741             if( pDirEntry != NULL &&
1742                 BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
1743             {
1744
1745                 pCurrentObject = pDirEntry->ObjectInformation;
1746
1747                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1748                               AFS_TRACE_LEVEL_ERROR,
1749                               "AFSLocateNameEntry (FO: %p) Deleted entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1750                               FileObject,
1751                               &pDirEntry->NameInformation.FileName,
1752                               pCurrentObject->FileId.Cell,
1753                               pCurrentObject->FileId.Volume,
1754                               pCurrentObject->FileId.Vnode,
1755                               pCurrentObject->FileId.Unique);
1756
1757                 //
1758                 // This entry was deleted through the invalidation call back so perform cleanup
1759                 // on the entry
1760                 //
1761
1762                 if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
1763                 {
1764
1765                     pParentObjectInfo = AFSFindObjectInfo( pCurrentObject->VolumeCB,
1766                                                            &pCurrentObject->ParentFileId);
1767                 }
1768
1769                 ASSERT( pParentObjectInfo != NULL);
1770
1771                 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
1772                                 TRUE);
1773
1774                 AFSAcquireExcl( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock,
1775                                 TRUE);
1776
1777                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1778
1779                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1780                               AFS_TRACE_LEVEL_VERBOSE,
1781                               "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1782                               &pDirEntry->NameInformation.FileName,
1783                               pDirEntry,
1784                               NULL,
1785                               lCount);
1786
1787                 ASSERT( lCount >= 0);
1788
1789                 if( lCount <= 0)
1790                 {
1791
1792                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING|AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1793                                   AFS_TRACE_LEVEL_VERBOSE,
1794                                   "AFSLocateNameEntry Deleting dir entry %p (%p) for %wZ\n",
1795                                   pDirEntry,
1796                                   pCurrentObject,
1797                                   &pDirEntry->NameInformation.FileName);
1798
1799                     //
1800                     // Remove and delete the directory entry from the parent list
1801                     //
1802
1803                     AFSDeleteDirEntry( pParentObjectInfo,
1804                                        pDirEntry);
1805
1806                     AFSAcquireShared( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
1807                                       TRUE);
1808
1809                     if( pCurrentObject->ObjectReferenceCount <= 0)
1810                     {
1811
1812                         if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
1813                         {
1814
1815                             AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1816                                           AFS_TRACE_LEVEL_VERBOSE,
1817                                           "AFSLocateNameEntry Removing object %p from volume tree\n",
1818                                           pCurrentObject);
1819
1820                             AFSRemoveHashEntry( &pCurrentObject->VolumeCB->ObjectInfoTree.TreeHead,
1821                                                 &pCurrentObject->TreeEntry);
1822
1823                             ClearFlag( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
1824                         }
1825                     }
1826
1827                     AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1828                 }
1829                 else
1830                 {
1831
1832                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1833                                   AFS_TRACE_LEVEL_VERBOSE,
1834                                   "AFSLocateNameEntry Setting DELETE flag in dir entry %p for %wZ\n",
1835                                   pDirEntry,
1836                                   &pDirEntry->NameInformation.FileName);
1837
1838                     SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
1839
1840                     AFSRemoveNameEntry( pParentObjectInfo,
1841                                         pDirEntry);
1842                 }
1843
1844                 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
1845
1846                 AFSReleaseResource( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock);
1847
1848                 AFSReleaseObjectInfo( &pParentObjectInfo);
1849
1850                 //
1851                 // We deleted the dir entry so check if there is any remaining portion
1852                 // of the name to process.
1853                 //
1854
1855                 if( uniRemainingPath.Length > 0)
1856                 {
1857
1858                     ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1859
1860                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1861                                   AFS_TRACE_LEVEL_VERBOSE,
1862                                   "AFSLocateNameEntry (FO: %p) Returning path not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1863                                   FileObject,
1864                                   &uniComponentName,
1865                                   pCurrentObject->FileId.Cell,
1866                                   pCurrentObject->FileId.Volume,
1867                                   pCurrentObject->FileId.Vnode,
1868                                   pCurrentObject->FileId.Unique);
1869                 }
1870                 else
1871                 {
1872
1873                     ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
1874
1875                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1876                                   AFS_TRACE_LEVEL_VERBOSE,
1877                                   "AFSLocateNameEntry (FO: %p) Returning name not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1878                                   FileObject,
1879                                   &uniComponentName,
1880                                   pCurrentObject->FileId.Cell,
1881                                   pCurrentObject->FileId.Volume,
1882                                   pCurrentObject->FileId.Vnode,
1883                                   pCurrentObject->FileId.Unique);
1884
1885                     //
1886                     // Pass back the directory entries
1887                     //
1888
1889                     *OutParentDirectoryCB = pParentDirEntry;
1890
1891                     *OutDirectoryCB = NULL;
1892
1893                     *OutVolumeCB = pCurrentVolume;
1894
1895                     *OutVolumeReferenceReason = VolumeReferenceReason;
1896
1897                     bReleaseCurrentVolume = FALSE;
1898
1899                     if( ComponentName != NULL)
1900                     {
1901
1902                         *ComponentName = uniComponentName;
1903                     }
1904
1905                     *RootPathName = uniFullPathName;
1906                 }
1907             }
1908
1909             if( ntStatus != STATUS_SUCCESS)
1910             {
1911
1912                 try_return( ntStatus);
1913             }
1914
1915             //
1916             // Decrement the previous parent
1917             //
1918
1919             lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
1920
1921             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1922                           AFS_TRACE_LEVEL_VERBOSE,
1923                           "AFSLocateNameEntry Decrement5 count on Parent %wZ DE %p Ccb %p Cnt %d\n",
1924                           &pParentDirEntry->NameInformation.FileName,
1925                           pParentDirEntry,
1926                           NULL,
1927                           lCount);
1928
1929             ASSERT( lCount >= 0);
1930
1931             //
1932             // If we ended up substituting a name in the component then update
1933             // the full path and update the pointers
1934             //
1935
1936             if( bSubstituteName)
1937             {
1938
1939                 BOOLEAN bRelativeOpen = FALSE;
1940
1941                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1942                               AFS_TRACE_LEVEL_VERBOSE_2,
1943                               "AFSLocateNameEntry (FO: %p) Substituting %wZ into %wZ Index %08lX\n",
1944                               FileObject,
1945                               &uniSearchName,
1946                               &uniComponentName,
1947                               ulSubstituteIndex);
1948
1949                 if( FileObject != NULL &&
1950                     FileObject->RelatedFileObject != NULL)
1951                 {
1952
1953                     bRelativeOpen = TRUE;
1954                 }
1955
1956                 //
1957                 // AFSSubstituteNameInPath will replace the uniFullPathName.Buffer
1958                 // and free the prior Buffer contents but only if the fourth
1959                 // parameter is TRUE.
1960                 //
1961
1962                 ntStatus = AFSSubstituteNameInPath( &uniFullPathName,
1963                                                     &uniComponentName,
1964                                                     &uniSearchName,
1965                                                     &uniRemainingPath,
1966                                                     bRelativeOpen ||
1967                                                             bAllocatedSymLinkBuffer ||
1968                                                             bSubstitutedName);
1969
1970                 if( !NT_SUCCESS( ntStatus))
1971                 {
1972
1973                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1974                                   AFS_TRACE_LEVEL_ERROR,
1975                                   "AFSLocateNameEntry (FO: %p) Failure to substitute %wZ into %wZ Index %08lX Status %08lX\n",
1976                                   FileObject,
1977                                   &uniSearchName,
1978                                   &uniComponentName,
1979                                   ulSubstituteIndex,
1980                                   ntStatus);
1981
1982                     try_return( ntStatus);
1983                 }
1984
1985                 //
1986                 // We have substituted a name into the buffer so if we do this again for this
1987                 // path, we need to free up the buffer we allocated.
1988                 //
1989
1990                 bSubstitutedName = TRUE;
1991             }
1992
1993             //
1994             // Update the search parameters
1995             //
1996
1997             uniPathName = uniRemainingPath;
1998
1999             //
2000             // Check if the is a SymLink entry but has no Target FileID or Name. In this
2001             // case it might be a DFS Link so let's go and evaluate it to be sure
2002             //
2003
2004             if( pCurrentObject->FileType == AFS_FILE_TYPE_SYMLINK &&
2005                 ( pCurrentObject->TargetFileId.Vnode == 0 ||
2006                   pDirEntry->NameInformation.TargetName.Length == 0))
2007             {
2008
2009                 ntStatus = AFSValidateSymLink( AuthGroup,
2010                                                pDirEntry);
2011
2012                 if( !NT_SUCCESS( ntStatus))
2013                 {
2014
2015                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2016                                   AFS_TRACE_LEVEL_ERROR,
2017                                   "AFSLocateNameEntry (FO: %p) Failed to evaluate possible DFS Link %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2018                                   FileObject,
2019                                   &pDirEntry->NameInformation.FileName,
2020                                   pCurrentObject->FileId.Cell,
2021                                   pCurrentObject->FileId.Volume,
2022                                   pCurrentObject->FileId.Vnode,
2023                                   pCurrentObject->FileId.Unique,
2024                                   ntStatus);
2025
2026                     try_return( ntStatus);
2027                 }
2028             }
2029
2030             //
2031             // Update the name array
2032             //
2033
2034             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2035                           AFS_TRACE_LEVEL_VERBOSE,
2036                           "AFSLocateNameEntry (FO: %p) Inserting name array entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2037                           FileObject,
2038                           &pDirEntry->NameInformation.FileName,
2039                           pCurrentObject->FileId.Cell,
2040                           pCurrentObject->FileId.Volume,
2041                           pCurrentObject->FileId.Vnode,
2042                           pCurrentObject->FileId.Unique);
2043
2044             ntStatus = AFSInsertNextElement( pNameArray,
2045                                              pDirEntry);
2046
2047             if( !NT_SUCCESS( ntStatus))
2048             {
2049
2050                 try_return( ntStatus);
2051             }
2052         }       // while (TRUE)
2053
2054 try_exit:
2055
2056         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2057                       AFS_TRACE_LEVEL_VERBOSE,
2058                       "AFSLocateNameEntry (FO: %p) Completed processing %wZ Status %08lX\n",
2059                       FileObject,
2060                       RootPathName,
2061                       ntStatus);
2062
2063         if( ( !NT_SUCCESS( ntStatus) &&
2064               ntStatus != STATUS_OBJECT_NAME_NOT_FOUND) ||
2065             ntStatus == STATUS_REPARSE)
2066         {
2067
2068             if( pDirEntry != NULL)
2069             {
2070
2071                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
2072
2073                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2074                               AFS_TRACE_LEVEL_VERBOSE,
2075                               "AFSLocateNameEntry Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
2076                               &pDirEntry->NameInformation.FileName,
2077                               pDirEntry,
2078                               NULL,
2079                               lCount);
2080
2081                 ASSERT( lCount >= 0);
2082             }
2083             else if( pParentDirEntry != NULL)
2084             {
2085
2086                 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
2087
2088                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2089                               AFS_TRACE_LEVEL_VERBOSE,
2090                               "AFSLocateNameEntry Decrement7 count on %wZ DE %p Ccb %p Cnt %d\n",
2091                               &pParentDirEntry->NameInformation.FileName,
2092                               pParentDirEntry,
2093                               NULL,
2094                               lCount);
2095
2096                 ASSERT( lCount >= 0);
2097             }
2098
2099             if( RootPathName->Buffer != uniFullPathName.Buffer)
2100             {
2101
2102                 AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
2103             }
2104         }
2105         else
2106         {
2107
2108             if( *OutParentDirectoryCB != NULL)
2109             {
2110
2111                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2112                               AFS_TRACE_LEVEL_VERBOSE,
2113                               "AFSLocateNameEntry Count on Parent %wZ DE %p Ccb %p Cnt %d\n",
2114                               &(*OutParentDirectoryCB)->NameInformation.FileName,
2115                               *OutParentDirectoryCB,
2116                               NULL,
2117                               (*OutParentDirectoryCB)->DirOpenReferenceCount);
2118             }
2119
2120             if( *OutDirectoryCB != NULL)
2121             {
2122
2123                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2124                               AFS_TRACE_LEVEL_VERBOSE,
2125                               "AFSLocateNameEntry Count on %wZ DE %p Ccb %p Cnt %d\n",
2126                               &(*OutDirectoryCB)->NameInformation.FileName,
2127                               *OutDirectoryCB,
2128                               NULL,
2129                               (*OutDirectoryCB)->DirOpenReferenceCount);
2130             }
2131         }
2132
2133         if( bReleaseCurrentVolume)
2134         {
2135
2136             ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
2137
2138             lCount = AFSVolumeDecrement( pCurrentVolume,
2139                                          VolumeReferenceReason);
2140
2141             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
2142                           AFS_TRACE_LEVEL_VERBOSE,
2143                           "AFSLocateNameEntry Decrement7 count on volume %p Reason %u Cnt %d\n",
2144                           pCurrentVolume,
2145                           VolumeReferenceReason,
2146                           lCount);
2147
2148             bReleaseCurrentVolume = FALSE;
2149         }
2150
2151         if( bSubstituteName &&
2152             uniSearchName.Buffer != NULL)
2153         {
2154
2155             AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
2156         }
2157     }
2158
2159     return ntStatus;
2160 }
2161
2162 NTSTATUS
2163 AFSCreateDirEntry( IN GUID            *AuthGroup,
2164                    IN AFSObjectInfoCB *ParentObjectInfo,
2165                    IN AFSDirectoryCB *ParentDirCB,
2166                    IN PUNICODE_STRING FileName,
2167                    IN PUNICODE_STRING ComponentName,
2168                    IN ULONG Attributes,
2169                    IN OUT AFSDirectoryCB **DirEntry)
2170 {
2171
2172     UNREFERENCED_PARAMETER(FileName);
2173     NTSTATUS ntStatus = STATUS_SUCCESS;
2174     AFSDirectoryCB *pDirNode = NULL, *pExistingDirNode = NULL;
2175     LARGE_INTEGER liFileSize = {0,0};
2176     LONG lCount;
2177
2178     __Enter
2179     {
2180
2181         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2182                       AFS_TRACE_LEVEL_VERBOSE_2,
2183                       "AFSCreateDirEntry Creating dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX\n",
2184                       &ParentDirCB->NameInformation.FileName,
2185                       ParentObjectInfo->FileId.Cell,
2186                       ParentObjectInfo->FileId.Volume,
2187                       ParentObjectInfo->FileId.Vnode,
2188                       ParentObjectInfo->FileId.Unique,
2189                       ComponentName,
2190                       Attributes);
2191
2192         //
2193         // OK, before inserting the node into the parent tree, issue
2194         // the request to the service for node creation
2195         // We will need to drop the lock on the parent node since the create
2196         // could cause a callback into the file system to invalidate it's cache
2197         //
2198
2199         ntStatus = AFSNotifyFileCreate( AuthGroup,
2200                                         ParentObjectInfo,
2201                                         &liFileSize,
2202                                         Attributes,
2203                                         ComponentName,
2204                                         &pDirNode);
2205
2206         //
2207         // If the returned status is STATUS_REPARSE then the entry exists
2208         // and we raced, get out.
2209
2210         if( ntStatus == STATUS_REPARSE)
2211         {
2212
2213             *DirEntry = pDirNode;
2214
2215             try_return( ntStatus = STATUS_SUCCESS);
2216         }
2217
2218         if( !NT_SUCCESS( ntStatus))
2219         {
2220
2221             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2222                           AFS_TRACE_LEVEL_ERROR,
2223                           "AFSCreateDirEntry Failed to create dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX Status %08lX\n",
2224                           &ParentDirCB->NameInformation.FileName,
2225                           ParentObjectInfo->FileId.Cell,
2226                           ParentObjectInfo->FileId.Volume,
2227                           ParentObjectInfo->FileId.Vnode,
2228                           ParentObjectInfo->FileId.Unique,
2229                           ComponentName,
2230                           Attributes,
2231                           ntStatus);
2232
2233             try_return( ntStatus);
2234         }
2235
2236         //
2237         // If AFSNotifyFileCreate returns pDirNode != NULL, then its
2238         // DirOpenReferenceCount is held.
2239         //
2240
2241         AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2242                         TRUE);
2243
2244         //
2245         // Before attempting to insert the new entry, check if we need to validate the parent
2246         //
2247
2248         if( BooleanFlagOn( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
2249         {
2250
2251             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2252                           AFS_TRACE_LEVEL_VERBOSE,
2253                           "AFSCreateDirEntry Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2254                           &ParentDirCB->NameInformation.FileName,
2255                           ParentObjectInfo->FileId.Cell,
2256                           ParentObjectInfo->FileId.Volume,
2257                           ParentObjectInfo->FileId.Vnode,
2258                           ParentObjectInfo->FileId.Unique);
2259
2260             ntStatus = AFSVerifyEntry( AuthGroup,
2261                                        ParentDirCB);
2262
2263             if( !NT_SUCCESS( ntStatus))
2264             {
2265
2266                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2267                               AFS_TRACE_LEVEL_ERROR,
2268                               "AFSCreateDirEntry Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2269                               &ParentDirCB->NameInformation.FileName,
2270                               ParentObjectInfo->FileId.Cell,
2271                               ParentObjectInfo->FileId.Volume,
2272                               ParentObjectInfo->FileId.Vnode,
2273                               ParentObjectInfo->FileId.Unique,
2274                               ntStatus);
2275
2276                 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2277
2278                 try_return( ntStatus);
2279             }
2280         }
2281
2282         //
2283         // Check for the entry in the event we raced with some other thread
2284         //
2285
2286         AFSLocateCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2287                                         (ULONG)pDirNode->CaseSensitiveTreeEntry.HashIndex,
2288                                         &pExistingDirNode);
2289
2290         if( pExistingDirNode != NULL)
2291         {
2292             if (AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
2293                                &pExistingDirNode->ObjectInformation->FileId))
2294             {
2295
2296                 if ( pExistingDirNode != pDirNode)
2297                 {
2298
2299                     lCount = InterlockedDecrement( &pDirNode->DirOpenReferenceCount);
2300
2301                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2302                                   AFS_TRACE_LEVEL_VERBOSE,
2303                                   "AFSCreateDirEntry Decrement count on %wZ DE %p Cnt %d\n",
2304                                   &pDirNode->NameInformation.FileName,
2305                                   pDirNode,
2306                                   lCount);
2307
2308                     AFSDeleteDirEntry( ParentObjectInfo,
2309                                        pDirNode);
2310
2311                     lCount = InterlockedIncrement( &pExistingDirNode->DirOpenReferenceCount);
2312
2313                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2314                                   AFS_TRACE_LEVEL_VERBOSE,
2315                                   "AFSCreateDirEntry Increment count on %wZ DE %p Cnt %d\n",
2316                                   &pExistingDirNode->NameInformation.FileName,
2317                                   pExistingDirNode,
2318                                   lCount);
2319
2320                     *DirEntry = pExistingDirNode;
2321                 }
2322
2323                 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2324
2325                 try_return( ntStatus = STATUS_SUCCESS);
2326             }
2327             else
2328             {
2329
2330                 //
2331                 // Need to tear down this entry and rebuild it below
2332                 //
2333
2334                 if( pExistingDirNode->DirOpenReferenceCount <= 0)
2335                 {
2336
2337                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2338                                   AFS_TRACE_LEVEL_VERBOSE,
2339                                   "AFSCreateDirEntry Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2340                                   pExistingDirNode,
2341                                   &pExistingDirNode->NameInformation.FileName,
2342                                   pExistingDirNode->ObjectInformation->FileId.Cell,
2343                                   pExistingDirNode->ObjectInformation->FileId.Volume,
2344                                   pExistingDirNode->ObjectInformation->FileId.Vnode,
2345                                   pExistingDirNode->ObjectInformation->FileId.Unique,
2346                                   pDirNode->ObjectInformation->FileId.Cell,
2347                                   pDirNode->ObjectInformation->FileId.Volume,
2348                                   pDirNode->ObjectInformation->FileId.Vnode,
2349                                   pDirNode->ObjectInformation->FileId.Unique);
2350
2351                     AFSDeleteDirEntry( ParentObjectInfo,
2352                                        pExistingDirNode);
2353                 }
2354                 else
2355                 {
2356
2357                     SetFlag( pExistingDirNode->Flags, AFS_DIR_ENTRY_DELETED);
2358
2359                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2360                                   AFS_TRACE_LEVEL_VERBOSE,
2361                                   "AFSCreateDirEntry Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2362                                   pExistingDirNode,
2363                                   &pExistingDirNode->NameInformation.FileName,
2364                                   pExistingDirNode->ObjectInformation->FileId.Cell,
2365                                   pExistingDirNode->ObjectInformation->FileId.Volume,
2366                                   pExistingDirNode->ObjectInformation->FileId.Vnode,
2367                                   pExistingDirNode->ObjectInformation->FileId.Unique,
2368                                   pDirNode->ObjectInformation->FileId.Cell,
2369                                   pDirNode->ObjectInformation->FileId.Volume,
2370                                   pDirNode->ObjectInformation->FileId.Vnode,
2371                                   pDirNode->ObjectInformation->FileId.Unique);
2372
2373                     AFSRemoveNameEntry( ParentObjectInfo,
2374                                         pExistingDirNode);
2375                 }
2376             }
2377         }
2378
2379         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2380                       AFS_TRACE_LEVEL_VERBOSE_2,
2381                       "AFSCreateDirEntry Inserting dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ\n",
2382                       &ParentDirCB->NameInformation.FileName,
2383                       ParentObjectInfo->FileId.Cell,
2384                       ParentObjectInfo->FileId.Volume,
2385                       ParentObjectInfo->FileId.Vnode,
2386                       ParentObjectInfo->FileId.Unique,
2387                       ComponentName);
2388
2389         //
2390         // Insert the directory node
2391         //
2392
2393         AFSInsertDirectoryNode( ParentObjectInfo,
2394                                 pDirNode,
2395                                 TRUE);
2396
2397         //
2398         // Pass back the dir entry
2399         //
2400
2401         *DirEntry = pDirNode;
2402
2403         AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2404
2405 try_exit:
2406
2407         NOTHING;
2408     }
2409
2410     return ntStatus;
2411 }
2412
2413 void
2414 AFSInsertDirectoryNode( IN AFSObjectInfoCB *ParentObjectInfo,
2415                         IN AFSDirectoryCB *DirEntry,
2416                         IN BOOLEAN InsertInEnumList)
2417 {
2418
2419     LONG lCount;
2420
2421     __Enter
2422     {
2423
2424         ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2425
2426         //
2427         // Insert the node into the directory node tree
2428         //
2429
2430         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2431                       AFS_TRACE_LEVEL_VERBOSE,
2432                       "AFSInsertDirectoryNode Insert DE %p for %wZ Clearing NOT_IN flag\n",
2433                       DirEntry,
2434                       &DirEntry->NameInformation.FileName);
2435
2436         ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
2437
2438         if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead == NULL)
2439         {
2440
2441             ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = DirEntry;
2442
2443             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2444                           AFS_TRACE_LEVEL_VERBOSE,
2445                           "AFSInsertDirectoryNode Insert DE %p to head of case sensitive tree for %wZ\n",
2446                           DirEntry,
2447                           &DirEntry->NameInformation.FileName);
2448         }
2449         else
2450         {
2451
2452             AFSInsertCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2453                                             DirEntry);
2454
2455             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2456                           AFS_TRACE_LEVEL_VERBOSE,
2457                           "AFSInsertDirectoryNode Insert DE %p to case sensitive tree for %wZ\n",
2458                           DirEntry,
2459                           &DirEntry->NameInformation.FileName);
2460         }
2461
2462         if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead == NULL)
2463         {
2464
2465             ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = DirEntry;
2466
2467             SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
2468
2469             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2470                           AFS_TRACE_LEVEL_VERBOSE,
2471                           "AFSInsertDirectoryNode Insert DE %p to head of case insensitive tree for %wZ\n",
2472                           DirEntry,
2473                           &DirEntry->NameInformation.FileName);
2474         }
2475         else
2476         {
2477
2478             AFSInsertCaseInsensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2479                                               DirEntry);
2480
2481             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2482                           AFS_TRACE_LEVEL_VERBOSE,
2483                           "AFSInsertDirectoryNode Insert DE %p to case insensitive tree for %wZ\n",
2484                           DirEntry,
2485                           &DirEntry->NameInformation.FileName);
2486         }
2487
2488         //
2489         // Into the shortname tree
2490         //
2491
2492         if( DirEntry->Type.Data.ShortNameTreeEntry.HashIndex != 0)
2493         {
2494
2495             if( ParentObjectInfo->Specific.Directory.ShortNameTree == NULL)
2496             {
2497
2498                 ParentObjectInfo->Specific.Directory.ShortNameTree = DirEntry;
2499
2500                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2501                               AFS_TRACE_LEVEL_VERBOSE,
2502                               "AFSInsertDirectoryNode Insert DE %p to head of shortname tree for %wZ\n",
2503                               DirEntry,
2504                               &DirEntry->NameInformation.FileName);
2505
2506                 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2507             }
2508             else
2509             {
2510
2511                 if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ParentObjectInfo->Specific.Directory.ShortNameTree,
2512                                                              DirEntry)))
2513                 {
2514                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2515                                   AFS_TRACE_LEVEL_VERBOSE,
2516                                   "AFSInsertDirectoryNode Failed to insert DE %p to shortname tree for %wZ\n",
2517                                   DirEntry,
2518                                   &DirEntry->NameInformation.FileName);
2519                 }
2520                 else
2521                 {
2522                     SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2523
2524                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2525                                   AFS_TRACE_LEVEL_VERBOSE,
2526                                   "AFSInsertDirectoryNode Insert DE %p to shortname tree for %wZ\n",
2527                                   DirEntry,
2528                                   &DirEntry->NameInformation.FileName);
2529                 }
2530             }
2531         }
2532
2533         if( InsertInEnumList)
2534         {
2535
2536             //
2537             // And insert the node into the directory list
2538             //
2539
2540             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2541                           AFS_TRACE_LEVEL_VERBOSE,
2542                           "AFSInsertDirectoryNode Inserting entry %p %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2543                           DirEntry,
2544                           &DirEntry->NameInformation.FileName,
2545                           DirEntry->ObjectInformation->FileId.Cell,
2546                           DirEntry->ObjectInformation->FileId.Volume,
2547                           DirEntry->ObjectInformation->FileId.Vnode,
2548                           DirEntry->ObjectInformation->FileId.Unique);
2549
2550             if( ParentObjectInfo->Specific.Directory.DirectoryNodeListHead == NULL)
2551             {
2552
2553                 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = DirEntry;
2554             }
2555             else
2556             {
2557
2558                 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail->ListEntry.fLink = (void *)DirEntry;
2559
2560                 DirEntry->ListEntry.bLink = (void *)ParentObjectInfo->Specific.Directory.DirectoryNodeListTail;
2561             }
2562
2563             ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = DirEntry;
2564
2565             SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2566
2567             lCount = InterlockedIncrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2568
2569             AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2570                           AFS_TRACE_LEVEL_VERBOSE,
2571                           "AFSInsertDirectoryNode Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2572                           &DirEntry->NameInformation.FileName,
2573                           lCount,
2574                           ParentObjectInfo->FileId.Cell,
2575                           ParentObjectInfo->FileId.Volume,
2576                           ParentObjectInfo->FileId.Vnode,
2577                           ParentObjectInfo->FileId.Unique);
2578         }
2579     }
2580
2581     return;
2582 }
2583
2584 void
2585 AFSDeleteDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
2586                    IN AFSDirectoryCB *DirEntry)
2587 {
2588
2589     LONG lCount;
2590
2591     __Enter
2592     {
2593
2594         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2595                       AFS_TRACE_LEVEL_VERBOSE,
2596                       "AFSDeleteDirEntry Deleting dir entry in parent %p Entry %p %wZ FID %08lX-%08lX-%08lX-%08lX RefCount %d\n",
2597                       ParentObjectInfo,
2598                       DirEntry,
2599                       &DirEntry->NameInformation.FileName,
2600                       DirEntry->ObjectInformation->FileId.Cell,
2601                       DirEntry->ObjectInformation->FileId.Volume,
2602                       DirEntry->ObjectInformation->FileId.Vnode,
2603                       DirEntry->ObjectInformation->FileId.Unique,
2604                       DirEntry->DirOpenReferenceCount);
2605
2606         ASSERT( DirEntry->DirOpenReferenceCount == 0);
2607
2608         AFSRemoveDirNodeFromParent( ParentObjectInfo,
2609                                     DirEntry,
2610                                     TRUE);
2611
2612         //
2613         // Free up the name buffer if it was reallocated
2614         //
2615
2616         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
2617         {
2618
2619             AFSExFreePoolWithTag( DirEntry->NameInformation.FileName.Buffer, 0);
2620         }
2621
2622         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
2623         {
2624
2625             AFSExFreePoolWithTag( DirEntry->NameInformation.TargetName.Buffer, 0);
2626         }
2627
2628         //
2629         // Dereference the object for this dir entry
2630         //
2631
2632         lCount = AFSObjectInfoDecrement( DirEntry->ObjectInformation,
2633                                          AFS_OBJECT_REFERENCE_DIRENTRY);
2634
2635         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2636                       AFS_TRACE_LEVEL_VERBOSE,
2637                       "AFSDeleteDirEntry Decrement count on object %p Cnt %d\n",
2638                       DirEntry->ObjectInformation,
2639                       lCount);
2640
2641         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_DELETED) &&
2642             DirEntry->ObjectInformation->Links == 0)
2643         {
2644
2645             SetFlag( DirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED);
2646         }
2647
2648         ExDeleteResourceLite( &DirEntry->NonPaged->Lock);
2649
2650         AFSExFreePoolWithTag( DirEntry->NonPaged, AFS_DIR_ENTRY_NP_TAG);
2651
2652         //
2653         // Free up the dir entry
2654         //
2655
2656         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
2657                       AFS_TRACE_LEVEL_VERBOSE,
2658                       "AFSDeleteDirEntry AFS_DIR_ENTRY_TAG deallocating %p\n",
2659                       DirEntry);
2660
2661         AFSExFreePoolWithTag( DirEntry, AFS_DIR_ENTRY_TAG);
2662     }
2663 }
2664
2665 NTSTATUS
2666 AFSRemoveDirNodeFromParent( IN AFSObjectInfoCB *ParentObjectInfo,
2667                             IN AFSDirectoryCB *DirEntry,
2668                             IN BOOLEAN RemoveFromEnumList)
2669 {
2670
2671     NTSTATUS ntStatus = STATUS_SUCCESS;
2672     LONG lCount;
2673
2674     __Enter
2675     {
2676
2677
2678         ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2679
2680         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2681                       AFS_TRACE_LEVEL_VERBOSE,
2682                       "AFSRemoveDirNodeFromParent Removing DirEntry %p %wZ FID %08lX-%08lX-%08lX-%08lX from Parent %p\n",
2683                       DirEntry,
2684                       &DirEntry->NameInformation.FileName,
2685                       DirEntry->ObjectInformation->FileId.Cell,
2686                       DirEntry->ObjectInformation->FileId.Volume,
2687                       DirEntry->ObjectInformation->FileId.Vnode,
2688                       DirEntry->ObjectInformation->FileId.Unique,
2689                       ParentObjectInfo);
2690
2691         if( !BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
2692         {
2693
2694             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2695                           AFS_TRACE_LEVEL_VERBOSE,
2696                           "AFSRemoveDirNodeFromParent Removing DirEntry %p name %wZ\n",
2697                           DirEntry,
2698                           &DirEntry->NameInformation.FileName);
2699
2700             AFSRemoveNameEntry( ParentObjectInfo,
2701                                 DirEntry);
2702         }
2703         else
2704         {
2705
2706             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2707                           AFS_TRACE_LEVEL_VERBOSE,
2708                           "AFSRemoveDirNodeFromParent DE %p for %wZ NOT removing entry due to flag set\n",
2709                           DirEntry,
2710                           &DirEntry->NameInformation.FileName);
2711
2712         }
2713
2714         if( RemoveFromEnumList &&
2715             BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST))
2716         {
2717
2718             //
2719             // And remove the entry from the enumeration list
2720             //
2721
2722             if( DirEntry->ListEntry.fLink == NULL)
2723             {
2724
2725                 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = (AFSDirectoryCB *)DirEntry->ListEntry.bLink;
2726             }
2727             else
2728             {
2729
2730                 ((AFSDirectoryCB *)DirEntry->ListEntry.fLink)->ListEntry.bLink = DirEntry->ListEntry.bLink;
2731             }
2732
2733             if( DirEntry->ListEntry.bLink == NULL)
2734             {
2735
2736                 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = (AFSDirectoryCB *)DirEntry->ListEntry.fLink;
2737             }
2738             else
2739             {
2740
2741                 ((AFSDirectoryCB *)DirEntry->ListEntry.bLink)->ListEntry.fLink = DirEntry->ListEntry.fLink;
2742             }
2743
2744             ASSERT( ParentObjectInfo->Specific.Directory.DirectoryNodeCount > 0);
2745
2746             lCount = InterlockedDecrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2747
2748             ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2749
2750             AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2751                           AFS_TRACE_LEVEL_VERBOSE,
2752                           "AFSRemoveDirNodeFromParent Removing entry %wZ Dec Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2753                           &DirEntry->NameInformation.FileName,
2754                           lCount,
2755                           ParentObjectInfo->FileId.Cell,
2756                           ParentObjectInfo->FileId.Volume,
2757                           ParentObjectInfo->FileId.Vnode,
2758                           ParentObjectInfo->FileId.Unique);
2759
2760             DirEntry->ListEntry.fLink = NULL;
2761             DirEntry->ListEntry.bLink = NULL;
2762         }
2763     }
2764
2765     return ntStatus;
2766 }
2767
2768 NTSTATUS
2769 AFSFixupTargetName( IN OUT PUNICODE_STRING FileName,
2770                     IN OUT PUNICODE_STRING TargetFileName)
2771 {
2772
2773     NTSTATUS ntStatus = STATUS_SUCCESS;
2774     UNICODE_STRING uniFileName;
2775
2776     __Enter
2777     {
2778
2779         //
2780         // We will process backwards from the end of the name looking
2781         // for the first \ we encounter
2782         //
2783
2784         uniFileName.Length = FileName->Length;
2785         uniFileName.MaximumLength = FileName->MaximumLength;
2786
2787         uniFileName.Buffer = FileName->Buffer;
2788
2789         while( TRUE)
2790         {
2791
2792             if( uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
2793             {
2794
2795                 //
2796                 // Subtract one more character off of the filename if it is not the root
2797                 //
2798
2799                 if( uniFileName.Length > sizeof( WCHAR))
2800                 {
2801
2802                     uniFileName.Length -= sizeof( WCHAR);
2803                 }
2804
2805                 //
2806                 // Now build up the target name
2807                 //
2808
2809                 TargetFileName->Length = FileName->Length - uniFileName.Length;
2810
2811                 //
2812                 // If we are not on the root then fixup the name
2813                 //
2814
2815                 if( uniFileName.Length > sizeof( WCHAR))
2816                 {
2817
2818                     TargetFileName->Length -= sizeof( WCHAR);
2819
2820                     TargetFileName->Buffer = &uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) + 1];
2821                 }
2822                 else
2823                 {
2824
2825                     TargetFileName->Buffer = &uniFileName.Buffer[ uniFileName.Length/sizeof( WCHAR)];
2826                 }
2827
2828                 //
2829                 // Fixup the passed back filename length