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