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

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSNameSupport.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // AFSLocateNameEntry
  43 //
  44 // On entry, *VolumeCB must have a held ReferenceCount provided by
  45 // the caller which will be released.  On successful exit, *VolumeCB
  46 // will be assigned the new current volume with a held ReferenceCount.
  47 //
  48 // On entry, *ParentDirectoryCB must have a held DirOpenReferenceCount
  49 // provided by the caller.
  50 //
  51
  52 NTSTATUS
  53 AFSLocateNameEntry( IN GUID *AuthGroup,
  54                     IN PFILE_OBJECT FileObject,
  55                     IN UNICODE_STRING *RootPathName,
  56                     IN UNICODE_STRING *ParsedPathName,
  57                     IN AFSNameArrayHdr *NameArray,
  58                     IN ULONG Flags,
  59                     IN OUT AFSVolumeCB **VolumeCB,
  60                     IN OUT AFSDirectoryCB **ParentDirectoryCB,
  61                     OUT AFSDirectoryCB **DirectoryCB,
  62                     OUT PUNICODE_STRING ComponentName)
  63 {
  64
  65     NTSTATUS          ntStatus = STATUS_SUCCESS;
  66     UNICODE_STRING    uniPathName, uniComponentName, uniRemainingPath, uniSearchName, uniFullPathName;
  67     ULONG             ulCRC = 0;
  68     AFSDirectoryCB   *pDirEntry = NULL, *pParentDirEntry = NULL;
  69     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
  70     UNICODE_STRING    uniSysName;
  71     ULONG             ulSubstituteIndex = 0;
  72     BOOLEAN           bSubstituteName = FALSE;
  73     AFSNameArrayHdr  *pNameArray = NameArray;
  74     BOOLEAN           bAllocatedSymLinkBuffer = FALSE;
  75     UNICODE_STRING    uniRelativeName, uniNoOpName;
  76     AFSObjectInfoCB  *pCurrentObject = NULL;
  77     AFSObjectInfoCB  *pParentObjectInfo = NULL;
  78     AFSVolumeCB      *pCurrentVolume = *VolumeCB;
  79     BOOLEAN           bReleaseCurrentVolume = TRUE;
  80     BOOLEAN           bSubstitutedName = FALSE;
  81     LONG              lCount;
  82
  83     __Enter
  84     {
  85
  86         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  87                       AFS_TRACE_LEVEL_VERBOSE_2,
  88                       "AFSLocateNameEntry (FO: %p) Processing full name %wZ\n",
  89                       FileObject,
  90                       RootPathName);
  91
  92         RtlInitUnicodeString( &uniSysName,
  93                               L"*@SYS");
  94
  95         RtlInitUnicodeString( &uniRelativeName,
  96                               L"..");
  97
  98         RtlInitUnicodeString( &uniNoOpName,
  99                               L".");
 100
 101         //
 102         // Cleanup some parameters
 103         //
 104
 105         if( ComponentName != NULL)
 106         {
 107
 108             ComponentName->Length = 0;
 109             ComponentName->MaximumLength = 0;
 110             ComponentName->Buffer = NULL;
 111         }
 112
 113         //
 114         // We will parse through the filename, locating the directory nodes until we encounter a cache miss
 115         // Starting at the root node
 116         //
 117
 118         pParentDirEntry = NULL;
 119
 120         pDirEntry = *ParentDirectoryCB;
 121
 122         uniPathName = *ParsedPathName;
 123
 124         uniFullPathName = *RootPathName;
 125
 126         uniComponentName.Length = uniComponentName.MaximumLength = 0;
 127         uniComponentName.Buffer = NULL;
 128
 129         uniRemainingPath.Length = uniRemainingPath.MaximumLength = 0;
 130         uniRemainingPath.Buffer = NULL;
 131
 132         uniSearchName.Length = uniSearchName.MaximumLength = 0;
 133         uniSearchName.Buffer = NULL;
 134
 135         while( TRUE)
 136         {
 137
 138             ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
 139
 140             ASSERT( pDirEntry->DirOpenReferenceCount > 0);
 141
 142             //
 143             // Check our total link count for this name array
 144             //
 145
 146             if( pNameArray->LinkCount >= (LONG)pDevExt->Specific.RDR.MaxLinkCount)
 147             {
 148
 149                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 150             }
 151
 152             pCurrentObject = pDirEntry->ObjectInformation;
 153
 154             KeQueryTickCount( &pCurrentObject->LastAccessCount);
 155
 156             //
 157             // Check that the directory entry is not deleted or pending delete
 158             //
 159
 160             if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED))
 161             {
 162
 163                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 164                               AFS_TRACE_LEVEL_ERROR,
 165                               "AFSLocateNameEntry (FO: %p) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 166                               FileObject,
 167                               &pDirEntry->NameInformation.FileName,
 168                               pCurrentObject->FileId.Cell,
 169                               pCurrentObject->FileId.Volume,
 170                               pCurrentObject->FileId.Vnode,
 171                               pCurrentObject->FileId.Unique,
 172                               STATUS_FILE_DELETED);
 173
 174                 try_return( ntStatus = STATUS_FILE_DELETED);
 175             }
 176
 177             if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
 178             {
 179
 180                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 181                               AFS_TRACE_LEVEL_ERROR,
 182                               "AFSLocateNameEntry (FO: %p) Delete pending on %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 183                               FileObject,
 184                               &pDirEntry->NameInformation.FileName,
 185                               pCurrentObject->FileId.Cell,
 186                               pCurrentObject->FileId.Volume,
 187                               pCurrentObject->FileId.Vnode,
 188                               pCurrentObject->FileId.Unique,
 189                               STATUS_DELETE_PENDING);
 190
 191                 try_return( ntStatus = STATUS_DELETE_PENDING);
 192             }
 193
 194             //
 195             // Check if the directory requires verification
 196             //
 197
 198             if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY) &&
 199                 ( pCurrentObject->FileType != AFS_FILE_TYPE_DIRECTORY ||
 200                   !AFSIsEnumerationInProcess( pCurrentObject)))
 201             {
 202
 203                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 204                               AFS_TRACE_LEVEL_VERBOSE,
 205                               "AFSLocateNameEntry (FO: %p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 206                               FileObject,
 207                               &pDirEntry->NameInformation.FileName,
 208                               pCurrentObject->FileId.Cell,
 209                               pCurrentObject->FileId.Volume,
 210                               pCurrentObject->FileId.Vnode,
 211                               pCurrentObject->FileId.Unique);
 212
 213                 //
 214                 // Directory TreeLock should be exclusively held
 215                 //
 216
 217                 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
 218                                 TRUE);
 219
 220                 ntStatus = AFSVerifyEntry( AuthGroup,
 221                                            pDirEntry);
 222
 223                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 224
 225                 if( !NT_SUCCESS( ntStatus))
 226                 {
 227
 228                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 229                                   AFS_TRACE_LEVEL_ERROR,
 230                                   "AFSLocateNameEntry (FO: %p) Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 231                                   FileObject,
 232                                   &pDirEntry->NameInformation.FileName,
 233                                   pCurrentObject->FileId.Cell,
 234                                   pCurrentObject->FileId.Volume,
 235                                   pCurrentObject->FileId.Vnode,
 236                                   pCurrentObject->FileId.Unique,
 237                                   ntStatus);
 238
 239                     try_return( ntStatus);
 240                 }
 241             }
 242
 243             //
 244             // Ensure the parent node has been evaluated, if not then go do it now
 245             //
 246
 247             if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) ||
 248                 pCurrentObject->FileType == AFS_FILE_TYPE_UNKNOWN)
 249             {
 250
 251                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 252                               AFS_TRACE_LEVEL_VERBOSE,
 253                               "AFSLocateNameEntry (FO: %p) Evaluating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 254                               FileObject,
 255                               &pDirEntry->NameInformation.FileName,
 256                               pCurrentObject->FileId.Cell,
 257                               pCurrentObject->FileId.Volume,
 258                               pCurrentObject->FileId.Vnode,
 259                               pCurrentObject->FileId.Unique);
 260
 261                 ntStatus = AFSEvaluateNode( AuthGroup,
 262                                             pDirEntry);
 263
 264                 if( !NT_SUCCESS( ntStatus))
 265                 {
 266
 267                     if ( ntStatus == STATUS_NOT_A_DIRECTORY)
 268                     {
 269
 270                         if ( pCurrentObject->ParentObjectInformation == NULL)
 271                         {
 272
 273                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 274                                           AFS_TRACE_LEVEL_ERROR,
 275                                           "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT NULL Status %08lX\n",
 276                                           FileObject,
 277                                           &pDirEntry->NameInformation.FileName,
 278                                           pCurrentObject->FileId.Cell,
 279                                           pCurrentObject->FileId.Volume,
 280                                           pCurrentObject->FileId.Vnode,
 281                                           pCurrentObject->FileId.Unique,
 282                                           ntStatus);
 283                         }
 284                         else
 285                         {
 286
 287                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 288                                           AFS_TRACE_LEVEL_ERROR,
 289                                           "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 290                                           FileObject,
 291                                           &pDirEntry->NameInformation.FileName,
 292                                           pCurrentObject->FileId.Cell,
 293                                           pCurrentObject->FileId.Volume,
 294                                           pCurrentObject->FileId.Vnode,
 295                                           pCurrentObject->FileId.Unique,
 296                                           pCurrentObject->ParentObjectInformation->FileId.Cell,
 297                                           pCurrentObject->ParentObjectInformation->FileId.Volume,
 298                                           pCurrentObject->ParentObjectInformation->FileId.Vnode,
 299                                           pCurrentObject->ParentObjectInformation->FileId.Unique,
 300                                           ntStatus);
 301                         }
 302                     }
 303                     else
 304                     {
 305                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 306                                       AFS_TRACE_LEVEL_ERROR,
 307                                       "AFSLocateNameEntry (FO: %p) Failed to evaluate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 308                                       FileObject,
 309                                       &pDirEntry->NameInformation.FileName,
 310                                       pCurrentObject->FileId.Cell,
 311                                       pCurrentObject->FileId.Volume,
 312                                       pCurrentObject->FileId.Vnode,
 313                                       pCurrentObject->FileId.Unique,
 314                                       ntStatus);
 315                     }
 316
 317                     try_return( ntStatus);
 318                 }
 319
 320                 ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
 321             }
 322
 323             //
 324             // If this is a mount point or symlink then go get the real directory node
 325             //
 326
 327             switch( pCurrentObject->FileType)
 328             {
 329
 330                 case AFS_FILE_TYPE_SYMLINK:
 331                 {
 332
 333                     UNICODE_STRING uniTempName;
 334                     WCHAR *pTmpBuffer = NULL;
 335                     LONG lLinkCount = 0;
 336
 337                     //
 338                     // Check if the flag is set to NOT evaluate a symlink
 339                     // and we are done with the parsing
 340                     //
 341
 342                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL) &&
 343                         uniRemainingPath.Length == 0)
 344                     {
 345
 346                         //
 347                         // Pass back the directory entries
 348                         //
 349
 350                         *ParentDirectoryCB = pParentDirEntry;
 351
 352                         *DirectoryCB = pDirEntry;
 353
 354                         *VolumeCB = pCurrentVolume;
 355
 356                         *RootPathName = uniFullPathName;
 357
 358                         try_return( ntStatus);
 359                     }
 360
 361                     AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
 362                                     TRUE);
 363
 364                     AFSAcquireExcl( &pDirEntry->NonPaged->Lock,
 365                                     TRUE);
 366
 367                     if( pDirEntry->NameInformation.TargetName.Length == 0)
 368                     {
 369
 370                         //
 371                         // We'll reset the DV to ensure we validate the metadata content
 372                         //
 373
 374                         pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
 375
 376                         SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
 377
 378                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 379                                       AFS_TRACE_LEVEL_VERBOSE,
 380                                       "AFSLocateNameEntry (FO: %p) Verifying symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 381                                       FileObject,
 382                                       &pDirEntry->NameInformation.FileName,
 383                                       pCurrentObject->FileId.Cell,
 384                                       pCurrentObject->FileId.Volume,
 385                                       pCurrentObject->FileId.Vnode,
 386                                       pCurrentObject->FileId.Unique);
 387
 388                         //
 389                         // Directory TreeLock should be exclusively held
 390                         //
 391
 392                         ntStatus = AFSVerifyEntry( AuthGroup,
 393                                                    pDirEntry);
 394
 395                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 396
 397                         if( !NT_SUCCESS( ntStatus))
 398                         {
 399
 400                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 401                                           AFS_TRACE_LEVEL_ERROR,
 402                                           "AFSLocateNameEntry (FO: %p) Failed to verify symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 403                                           FileObject,
 404                                           &pDirEntry->NameInformation.FileName,
 405                                           pCurrentObject->FileId.Cell,
 406                                           pCurrentObject->FileId.Volume,
 407                                           pCurrentObject->FileId.Vnode,
 408                                           pCurrentObject->FileId.Unique,
 409                                           ntStatus);
 410
 411                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 412
 413                             try_return( ntStatus);
 414                         }
 415
 416                         //
 417                         // If the type changed then reprocess this entry
 418                         //
 419
 420                         if( pCurrentObject->FileType != AFS_FILE_TYPE_SYMLINK)
 421                         {
 422
 423                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 424
 425                             continue;
 426                         }
 427                     }
 428                     else
 429                     {
 430
 431                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
 432                     }
 433
 434                     //
 435                     // If we were given a zero length target name then deny access to the entry
 436                     //
 437
 438                     if( pDirEntry->NameInformation.TargetName.Length == 0)
 439                     {
 440
 441                         ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
 442
 443                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 444                                       AFS_TRACE_LEVEL_ERROR,
 445                                       "AFSLocateNameEntry (FO: %p) Failed to retrieve target name for symlink %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 446                                       FileObject,
 447                                       &pDirEntry->NameInformation.FileName,
 448                                       pCurrentObject->FileId.Cell,
 449                                       pCurrentObject->FileId.Volume,
 450                                       pCurrentObject->FileId.Vnode,
 451                                       pCurrentObject->FileId.Unique,
 452                                       ntStatus);
 453
 454                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 455
 456                         try_return( ntStatus);
 457                     }
 458
 459                     if( AFSIsRelativeName( &pDirEntry->NameInformation.TargetName))
 460                     {
 461
 462                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 463                                       AFS_TRACE_LEVEL_VERBOSE,
 464                                       "AFSLocateNameEntry (FO: %p) Processing relative symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 465                                       FileObject,
 466                                       &pDirEntry->NameInformation.TargetName,
 467                                       &pDirEntry->NameInformation.FileName,
 468                                       pCurrentObject->FileId.Cell,
 469                                       pCurrentObject->FileId.Volume,
 470                                       pCurrentObject->FileId.Vnode,
 471                                       pCurrentObject->FileId.Unique);
 472
 473                         //
 474                         // We'll substitute this name into the current process name
 475                         // starting at where we sit in the path
 476                         //
 477
 478                         uniTempName.Length = 0;
 479                         uniTempName.MaximumLength = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer) +
 480                                                                     pDirEntry->NameInformation.TargetName.Length +
 481                                                                     sizeof( WCHAR) +
 482                                                                     uniRemainingPath.Length;
 483
 484                         uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 485                                                                                 uniTempName.MaximumLength,
 486                                                                                 AFS_NAME_BUFFER_ONE_TAG);
 487
 488                         if( uniTempName.Buffer == NULL)
 489                         {
 490
 491                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 492
 493                             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 494                         }
 495
 496                         //
 497                         // We have so first copy in the portion up to the component
 498                         // name
 499                         //
 500
 501                         RtlCopyMemory( uniTempName.Buffer,
 502                                        uniFullPathName.Buffer,
 503                                        (ULONG)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer));
 504
 505                         uniTempName.Length = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer);
 506
 507                         if( bAllocatedSymLinkBuffer ||
 508                             bSubstitutedName)
 509                         {
 510
 511                             pTmpBuffer = uniFullPathName.Buffer;
 512                         }
 513
 514                         bAllocatedSymLinkBuffer = TRUE;
 515
 516                         //
 517                         // Have we parsed this name yet? Better have at least once ...
 518                         //
 519
 520                         if( uniComponentName.Length == 0)
 521                         {
 522                             ASSERT( FALSE);
 523                         }
 524
 525                         //
 526                         // Copy in the target name ...
 527                         //
 528
 529                         RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 530                                        pDirEntry->NameInformation.TargetName.Buffer,
 531                                        pDirEntry->NameInformation.TargetName.Length);
 532
 533                         uniPathName.Buffer = &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)];
 534
 535                         uniPathName.Length += pDirEntry->NameInformation.TargetName.Length;
 536                         uniPathName.MaximumLength = uniTempName.MaximumLength;
 537
 538                         uniTempName.Length += pDirEntry->NameInformation.TargetName.Length;
 539
 540                         //
 541                         // And now any remaining portion of the name
 542                         //
 543
 544                         if( uniRemainingPath.Length > 0)
 545                         {
 546
 547                             if( uniRemainingPath.Buffer[ 0] != L'\\')
 548                             {
 549
 550                                 uniRemainingPath.Buffer--;
 551                                 uniRemainingPath.Length += sizeof( WCHAR);
 552
 553                                 uniPathName.Length += sizeof( WCHAR);
 554                             }
 555
 556                             RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 557                                            uniRemainingPath.Buffer,
 558                                            uniRemainingPath.Length);
 559
 560                             uniTempName.Length += uniRemainingPath.Length;
 561                         }
 562
 563                         uniFullPathName = uniTempName;
 564
 565                         if( pTmpBuffer != NULL)
 566                         {
 567
 568                             AFSExFreePoolWithTag( pTmpBuffer, 0);
 569                         }
 570
 571                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 572
 573                         //
 574                         // Dereference the current entry ..
 575                         //
 576
 577                         lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 578
 579                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 580                                       AFS_TRACE_LEVEL_VERBOSE,
 581                                       "AFSLocateNameEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
 582                                       &pDirEntry->NameInformation.FileName,
 583                                       pDirEntry,
 584                                       NULL,
 585                                       lCount);
 586
 587                         ASSERT( lCount >= 0);
 588
 589                         //
 590                         // OK, need to back up one entry for the correct parent since the current
 591                         // entry we are on is the symlink itself
 592                         //
 593
 594                         pDirEntry = AFSBackupEntry( pNameArray);
 595
 596                         //
 597                         // Increment our reference on this dir entry
 598                         //
 599
 600                         lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 601
 602                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 603                                       AFS_TRACE_LEVEL_VERBOSE,
 604                                       "AFSLocateNameEntry Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
 605                                       &pDirEntry->NameInformation.FileName,
 606                                       pDirEntry,
 607                                       NULL,
 608                                       lCount);
 609
 610                         if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
 611                         {
 612
 613                             pParentDirEntry = NULL;
 614                         }
 615                         else
 616                         {
 617
 618                             pParentDirEntry = AFSGetParentEntry( pNameArray);
 619
 620                             ASSERT( pParentDirEntry != pDirEntry);
 621                         }
 622                     }
 623                     else
 624                     {
 625
 626                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 627                                       AFS_TRACE_LEVEL_VERBOSE,
 628                                       "AFSLocateNameEntry (FO: %p) Processing absolute symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 629                                       FileObject,
 630                                       &pDirEntry->NameInformation.TargetName,
 631                                       &pDirEntry->NameInformation.FileName,
 632                                       pCurrentObject->FileId.Cell,
 633                                       pCurrentObject->FileId.Volume,
 634                                       pCurrentObject->FileId.Vnode,
 635                                       pCurrentObject->FileId.Unique);
 636
 637                         if ( !AFSIsAbsoluteAFSName( &pDirEntry->NameInformation.TargetName))
 638                         {
 639
 640                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 641                                           AFS_TRACE_LEVEL_ERROR,
 642                                           "AFSLocateNameEntry Name %wZ contains invalid server name\n",
 643                                           &pDirEntry->NameInformation.TargetName);
 644
 645                             //
 646                             // The correct response would be STATUS_OBJECT_PATH_INVALID
 647                             // but that prevents cmd.exe from performing a recursive
 648                             // directory enumeration when opening a directory entry
 649                             // that represents a symlink to an invalid path is discovered.
 650                             //
 651
 652                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 653
 654                             try_return( ntStatus = STATUS_OBJECT_PATH_NOT_FOUND);
 655                         }
 656
 657                         //
 658                         // We'll substitute this name into the current process name
 659                         // starting at where we sit in the path
 660                         //
 661
 662                         uniTempName.Length = 0;
 663                         uniTempName.MaximumLength = pDirEntry->NameInformation.TargetName.Length +
 664                                                                     sizeof( WCHAR) +
 665                                                                     uniRemainingPath.Length;
 666
 667                         uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
 668                                                                                 uniTempName.MaximumLength,
 669                                                                                 AFS_NAME_BUFFER_TWO_TAG);
 670
 671                         if( uniTempName.Buffer == NULL)
 672                         {
 673
 674                             AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 675
 676                             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 677                         }
 678
 679                         if( bAllocatedSymLinkBuffer ||
 680                             bSubstitutedName)
 681                         {
 682
 683                             pTmpBuffer = uniFullPathName.Buffer;
 684                         }
 685
 686                         bAllocatedSymLinkBuffer = TRUE;
 687
 688                         //
 689                         // Have we parsed this name yet? Better have at least once ...
 690                         //
 691
 692                         if( uniComponentName.Length == 0)
 693                         {
 694                             ASSERT( FALSE);
 695                         }
 696
 697                         //
 698                         // Copy in the target name ...
 699                         //
 700
 701                         RtlCopyMemory( uniTempName.Buffer,
 702                                        &pDirEntry->NameInformation.TargetName.Buffer[ AFSMountRootName.Length/sizeof( WCHAR)],
 703                                        pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length);
 704
 705                         uniTempName.Length = pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length;
 706
 707                         //
 708                         // And now any remaining portion of the name
 709                         //
 710
 711                         if( uniRemainingPath.Length > 0)
 712                         {
 713
 714                             if( uniRemainingPath.Buffer[ 0] != L'\\')
 715                             {
 716
 717                                 uniRemainingPath.Buffer--;
 718                                 uniRemainingPath.Length += sizeof( WCHAR);
 719                             }
 720
 721                             RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
 722                                            uniRemainingPath.Buffer,
 723                                            uniRemainingPath.Length);
 724
 725                             uniTempName.Length += uniRemainingPath.Length;
 726                         }
 727
 728                         uniFullPathName = uniTempName;
 729
 730                         uniPathName = uniTempName;
 731
 732                         if( pTmpBuffer != NULL)
 733                         {
 734
 735                             AFSExFreePoolWithTag( pTmpBuffer, 0);
 736                         }
 737
 738                         AFSReleaseResource( &pDirEntry->NonPaged->Lock);
 739
 740                         //
 741                         // If our current volume is not the global root then make it so ...
 742                         //
 743
 744                         if( pCurrentVolume != AFSGlobalRoot)
 745                         {
 746
 747                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 748                                           AFS_TRACE_LEVEL_VERBOSE,
 749                                           "AFSLocateNameEntry (FO: %p) Current volume not global, resetting for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 750                                           FileObject,
 751                                           &pDirEntry->NameInformation.FileName,
 752                                           pCurrentObject->FileId.Cell,
 753                                           pCurrentObject->FileId.Volume,
 754                                           pCurrentObject->FileId.Vnode,
 755                                           pCurrentObject->FileId.Unique);
 756
 757                             lCount = InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
 758
 759                             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 760                                           AFS_TRACE_LEVEL_VERBOSE,
 761                                           "AFSLocateNameEntry Decrement count on volume %p Cnt %d\n",
 762                                           pCurrentVolume,
 763                                           lCount);
 764
 765                             pCurrentVolume = AFSGlobalRoot;
 766
 767                             lCount = InterlockedIncrement( &pCurrentVolume->VolumeReferenceCount);
 768
 769                             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 770                                           AFS_TRACE_LEVEL_VERBOSE,
 771                                           "AFSLocateNameEntry Increment count on volume %p Cnt %d\n",
 772                                           pCurrentVolume,
 773                                           lCount);
 774                         }
 775
 776                         //
 777                         // Dereference our current dir entry
 778                         //
 779
 780                         lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 781
 782                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 783                                       AFS_TRACE_LEVEL_VERBOSE,
 784                                       "AFSLocateNameEntry Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
 785                                       &pDirEntry->NameInformation.FileName,
 786                                       pDirEntry,
 787                                       NULL,
 788                                       lCount);
 789
 790                         ASSERT( lCount >= 0);
 791
 792                         pDirEntry = pCurrentVolume->DirectoryCB;
 793
 794                         //
 795                         // Reference the new dir entry
 796                         //
 797
 798                         lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 799
 800                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 801                                       AFS_TRACE_LEVEL_VERBOSE,
 802                                       "AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
 803                                       &pDirEntry->NameInformation.FileName,
 804                                       pDirEntry,
 805                                       NULL,
 806                                       lCount);
 807
 808                         //
 809                         // Reset the name array
 810                         // Persist the link count in the name array
 811                         //
 812
 813                         lLinkCount = pNameArray->LinkCount;
 814
 815                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 816                                       AFS_TRACE_LEVEL_VERBOSE,
 817                                       "AFSLocateNameEntry (FO: %p) Resetting name array for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 818                                       FileObject,
 819                                       &pDirEntry->NameInformation.FileName,
 820                                       pCurrentObject->FileId.Cell,
 821                                       pCurrentObject->FileId.Volume,
 822                                       pCurrentObject->FileId.Vnode,
 823                                       pCurrentObject->FileId.Unique);
 824
 825                         AFSResetNameArray( pNameArray,
 826                                            pDirEntry);
 827
 828                         pNameArray->LinkCount = lLinkCount;
 829
 830                         pParentDirEntry = NULL;
 831                     }
 832
 833                     //
 834                     // Increment our link count
 835                     //
 836
 837                     lCount = InterlockedIncrement( &pNameArray->LinkCount);
 838
 839                     continue;
 840                 }
 841
 842                 case AFS_FILE_TYPE_MOUNTPOINT:
 843                 {
 844
 845                     //
 846                     // Check if the flag is set to NOT evaluate a mount point
 847                     // and we are done with the parsing
 848                     //
 849
 850                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL) &&
 851                         uniRemainingPath.Length == 0)
 852                     {
 853
 854                         //
 855                         // Pass back the directory entries
 856                         //
 857
 858                         *ParentDirectoryCB = pParentDirEntry;
 859
 860                         *DirectoryCB = pDirEntry;
 861
 862                         *VolumeCB = pCurrentVolume;
 863
 864                         *RootPathName = uniFullPathName;
 865
 866                         try_return( ntStatus);
 867                     }
 868
 869                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 870                                   AFS_TRACE_LEVEL_VERBOSE,
 871                                   "AFSLocateNameEntry (FO: %p) Building MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
 872                                   FileObject,
 873                                   &pDirEntry->NameInformation.FileName,
 874                                   pCurrentObject->FileId.Cell,
 875                                   pCurrentObject->FileId.Volume,
 876                                   pCurrentObject->FileId.Vnode,
 877                                   pCurrentObject->FileId.Unique);
 878
 879                     //
 880                     // Go retrieve the target entry for this node
 881                     // Release the current volume cb entry since we would
 882                     // have lock inversion in the following call
 883                     // Also decrement the ref count on the volume
 884                     //
 885
 886                     ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
 887
 888                     lCount = InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
 889
 890                     AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
 891                                   AFS_TRACE_LEVEL_VERBOSE,
 892                                   "AFSLocateNameEntry Decrement2 count on volume %p Cnt %d\n",
 893                                   pCurrentVolume,
 894                                   lCount);
 895
 896                     ntStatus = AFSBuildMountPointTarget( AuthGroup,
 897                                                          pDirEntry,
 898                                                          &pCurrentVolume);
 899
 900                     if( !NT_SUCCESS( ntStatus))
 901                     {
 902
 903                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 904                                       AFS_TRACE_LEVEL_ERROR,
 905                                       "AFSLocateNameEntry (FO: %p) Failed to build MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
 906                                       FileObject,
 907                                       &pDirEntry->NameInformation.FileName,
 908                                       pCurrentObject->FileId.Cell,
 909                                       pCurrentObject->FileId.Volume,
 910                                       pCurrentObject->FileId.Vnode,
 911                                       pCurrentObject->FileId.Unique,
 912                                       ntStatus);
 913
 914                         //
 915                         // We already decremented the current volume above
 916                         //
 917
 918                         bReleaseCurrentVolume = FALSE;
 919
 920                         try_return( ntStatus);
 921                     }
 922
 923                     ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
 924
 925                     //
 926                     // We want to restart processing here on the new parent ...
 927                     // Deref and ref count the entries
 928                     //
 929
 930                     lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
 931
 932                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 933                                   AFS_TRACE_LEVEL_VERBOSE,
 934                                   "AFSLocateNameEntry Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
 935                                   &pDirEntry->NameInformation.FileName,
 936                                   pDirEntry,
 937                                   NULL,
 938                                   lCount);
 939
 940                     ASSERT( lCount >= 0);
 941
 942                     pDirEntry = pCurrentVolume->DirectoryCB;
 943
 944                     lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
 945
 946                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 947                                   AFS_TRACE_LEVEL_VERBOSE,
 948                                   "AFSLocateNameEntry Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
 949                                   &pDirEntry->NameInformation.FileName,
 950                                   pDirEntry,
 951                                   NULL,
 952                                   lCount);
 953
 954                     //
 955                     // The name array stores both the mount point and the target.
 956                     // Insert the target.
 957                     //
 958
 959                     AFSInsertNextElement( pNameArray,
 960                                           pDirEntry);
 961
 962                     pParentDirEntry = NULL;
 963
 964                     //
 965                     // Increment our link count
 966                     //
 967
 968                     lCount = InterlockedIncrement( &pNameArray->LinkCount);
 969
 970                     continue;
 971                 }
 972
 973                 case AFS_FILE_TYPE_DFSLINK:
 974                 {
 975
 976                     if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL))
 977                     {
 978
 979                         //
 980                         // Pass back the directory entries
 981                         //
 982
 983                         *ParentDirectoryCB = pParentDirEntry;
 984
 985                         *DirectoryCB = pDirEntry;
 986
 987                         *VolumeCB = pCurrentVolume;
 988
 989                         *RootPathName = uniFullPathName;
 990
 991                         try_return( ntStatus);
 992                     }
 993
 994                     //
 995                     // This is a DFS link so we need to update the file name and return STATUS_REPARSE to the
 996                     // system for it to reevaluate it
 997                     //
 998
 999                     if( FileObject != NULL)
1000                     {
1001
1002                         ntStatus = AFSProcessDFSLink( pDirEntry,
1003                                                       FileObject,
1004                                                       &uniRemainingPath,
1005                                                       AuthGroup);
1006                     }
1007                     else
1008                     {
1009
1010                         //
1011                         // This is where we have been re-entered from an NP evaluation call via the BuildBranch()
1012                         // routine.
1013                         //
1014
1015                         ntStatus = STATUS_INVALID_PARAMETER;
1016                     }
1017
1018                     if( ntStatus != STATUS_SUCCESS &&
1019                         ntStatus != STATUS_REPARSE)
1020                     {
1021
1022                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1023                                       AFS_TRACE_LEVEL_ERROR,
1024                                       "AFSLocateNameEntry (FO: %p) Failed to process DFSLink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1025                                       FileObject,
1026                                       &pDirEntry->NameInformation.FileName,
1027                                       pCurrentObject->FileId.Cell,
1028                                       pCurrentObject->FileId.Volume,
1029                                       pCurrentObject->FileId.Vnode,
1030                                       pCurrentObject->FileId.Unique,
1031                                       ntStatus);
1032                     }
1033
1034                     try_return( ntStatus);
1035                 }
1036
1037                 case AFS_FILE_TYPE_UNKNOWN:
1038                 case AFS_FILE_TYPE_INVALID:
1039                 {
1040
1041                     //
1042                     // Something was not processed ...
1043                     //
1044
1045                     try_return( ntStatus = STATUS_ACCESS_DENIED);
1046                 }
1047
1048             }   /* end of switch */
1049
1050             //
1051             // If the parent is not initialized then do it now
1052             //
1053
1054             if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
1055                 !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1056             {
1057
1058                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1059                               AFS_TRACE_LEVEL_VERBOSE,
1060                               "AFSLocateNameEntry (FO: %p) Enumerating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1061                               FileObject,
1062                               &pDirEntry->NameInformation.FileName,
1063                               pCurrentObject->FileId.Cell,
1064                               pCurrentObject->FileId.Volume,
1065                               pCurrentObject->FileId.Vnode,
1066                               pCurrentObject->FileId.Unique);
1067
1068                 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
1069                                 TRUE);
1070
1071                 if( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1072                 {
1073
1074                     ntStatus = AFSEnumerateDirectory( AuthGroup,
1075                                                       pCurrentObject,
1076                                                       TRUE);
1077
1078                     if( !NT_SUCCESS( ntStatus))
1079                     {
1080
1081                         AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1082
1083                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1084                                       AFS_TRACE_LEVEL_ERROR,
1085                                       "AFSLocateNameEntry (FO: %p) Failed to enumerate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1086                                       FileObject,
1087                                       &pDirEntry->NameInformation.FileName,
1088                                       pCurrentObject->FileId.Cell,
1089                                       pCurrentObject->FileId.Volume,
1090                                       pCurrentObject->FileId.Vnode,
1091                                       pCurrentObject->FileId.Unique,
1092                                       ntStatus);
1093
1094                         try_return( ntStatus);
1095                     }
1096
1097                     SetFlag( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1098                 }
1099
1100                 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1101             }
1102             else if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
1103             {
1104
1105                 if( uniPathName.Length > 0)
1106                 {
1107
1108                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1109                                   AFS_TRACE_LEVEL_ERROR,
1110                                   "AFSLocateNameEntry (FO: %p) Encountered file node %wZ FID %08lX-%08lX-%08lX-%08lX in path processing\n",
1111                                   FileObject,
1112                                   &pDirEntry->NameInformation.FileName,
1113                                   pCurrentObject->FileId.Cell,
1114                                   pCurrentObject->FileId.Volume,
1115                                   pCurrentObject->FileId.Vnode,
1116                                   pCurrentObject->FileId.Unique);
1117
1118                     // The proper error code to return would be STATUS_OBJECT_PATH_INVALID because
1119                     // one of the components of the path is not a directory.  However, returning
1120                     // that error prevents IIS 7 and 7.5 from being able to serve data out of AFS.
1121                     // Instead IIS insists on treating the target file as if it is a directory containing
1122                     // a potential web.config file.  NTFS and LanMan return STATUS_OBJECT_PATH_NOT_FOUND.
1123                     // AFS will follow suit.
1124
1125                     ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1126                 }
1127                 else
1128                 {
1129
1130                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1131                                   AFS_TRACE_LEVEL_VERBOSE,
1132                                   "AFSLocateNameEntry (FO: %p) Returning file %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1133                                   FileObject,
1134                                   &pDirEntry->NameInformation.FileName,
1135                                   pCurrentObject->FileId.Cell,
1136                                   pCurrentObject->FileId.Volume,
1137                                   pCurrentObject->FileId.Vnode,
1138                                   pCurrentObject->FileId.Unique);
1139
1140                     //
1141                     // Pass back the directory entries
1142                     //
1143
1144                     *ParentDirectoryCB = pParentDirEntry;
1145
1146                     *DirectoryCB = pDirEntry;
1147
1148                     *VolumeCB = pCurrentVolume;
1149
1150                     *RootPathName = uniFullPathName;
1151                 }
1152
1153                 try_return( ntStatus);
1154             }
1155
1156             //
1157             // If we are at the end of the processing, set our returned information and get out
1158             //
1159
1160             if( uniPathName.Length == 0)
1161             {
1162
1163                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1164                               AFS_TRACE_LEVEL_VERBOSE,
1165                               "AFSLocateNameEntry (FO: %p) Completed processing returning %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1166                               FileObject,
1167                               &pDirEntry->NameInformation.FileName,
1168                               pCurrentObject->FileId.Cell,
1169                               pCurrentObject->FileId.Volume,
1170                               pCurrentObject->FileId.Vnode,
1171                               pCurrentObject->FileId.Unique);
1172
1173                 //
1174                 // Pass back the directory entries
1175                 //
1176
1177                 *ParentDirectoryCB = pParentDirEntry;
1178
1179                 *DirectoryCB = pDirEntry;
1180
1181                 *VolumeCB = pCurrentVolume;
1182
1183                 *RootPathName = uniFullPathName;
1184
1185                 try_return( ntStatus);
1186             }
1187
1188             //
1189             // We may have returned to the top of the while( TRUE)
1190             //
1191             if( bSubstituteName &&
1192                 uniSearchName.Buffer != NULL)
1193             {
1194
1195                 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1196
1197                 bSubstituteName = FALSE;
1198
1199                 uniSearchName.Length = uniSearchName.MaximumLength = 0;
1200                 uniSearchName.Buffer = NULL;
1201             }
1202
1203             ulSubstituteIndex = 1;
1204
1205             ntStatus = STATUS_SUCCESS;
1206
1207             //
1208             // Get the next component name
1209             //
1210
1211             FsRtlDissectName( uniPathName,
1212                               &uniComponentName,
1213                               &uniRemainingPath);
1214
1215             //
1216             // Check for the . and .. in the path
1217             //
1218
1219             if( RtlCompareUnicodeString( &uniComponentName,
1220                                          &uniNoOpName,
1221                                          TRUE) == 0)
1222             {
1223
1224                 uniPathName = uniRemainingPath;
1225
1226                 continue;
1227             }
1228
1229             if( RtlCompareUnicodeString( &uniComponentName,
1230                                          &uniRelativeName,
1231                                          TRUE) == 0)
1232             {
1233
1234                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1235                               AFS_TRACE_LEVEL_VERBOSE,
1236                               "AFSLocateNameEntry (FO: %p) Backing up entry from %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1237                               FileObject,
1238                               &pDirEntry->NameInformation.FileName,
1239                               pCurrentObject->FileId.Cell,
1240                               pCurrentObject->FileId.Volume,
1241                               pCurrentObject->FileId.Vnode,
1242                               pCurrentObject->FileId.Unique);
1243
1244                 //
1245                 // Need to back up one entry in the name array
1246                 //
1247                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1248
1249                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1250                               AFS_TRACE_LEVEL_VERBOSE,
1251                               "AFSLocateNameEntry Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
1252                               &pDirEntry->NameInformation.FileName,
1253                               pDirEntry,
1254                               NULL,
1255                               lCount);
1256
1257                 ASSERT( lCount >= 0);
1258
1259                 pDirEntry = AFSBackupEntry( NameArray);
1260
1261                 if( pDirEntry == NULL)
1262                 {
1263
1264                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1265                                   AFS_TRACE_LEVEL_ERROR,
1266                                   "AFSLocateNameEntry AFSBackupEntry failed\n");
1267
1268                     try_return(ntStatus = STATUS_OBJECT_PATH_INVALID);
1269                 }
1270
1271                 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1272
1273                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1274                               AFS_TRACE_LEVEL_VERBOSE,
1275                               "AFSLocateNameEntry Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
1276                               &pDirEntry->NameInformation.FileName,
1277                               pDirEntry,
1278                               NULL,
1279                               lCount);
1280
1281                 if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
1282                 {
1283
1284                     pParentDirEntry = NULL;
1285                 }
1286                 else
1287                 {
1288
1289                     pParentDirEntry = AFSGetParentEntry( pNameArray);
1290
1291                     ASSERT( pParentDirEntry != pDirEntry);
1292                 }
1293
1294                 uniPathName = uniRemainingPath;
1295
1296                 continue;
1297             }
1298
1299             //
1300             // Update our pointers
1301             //
1302
1303             pParentDirEntry = pDirEntry;
1304
1305             pDirEntry = NULL;
1306
1307             uniSearchName = uniComponentName;
1308
1309             while( pDirEntry == NULL)
1310             {
1311
1312                 //
1313                 // If the SearchName contains @SYS then we perform the substitution.
1314                 // If there is no substitution we give up.
1315                 //
1316
1317                 if( !bSubstituteName &&
1318                     FsRtlIsNameInExpression( &uniSysName,
1319                                              &uniSearchName,
1320                                              TRUE,
1321                                              NULL))
1322                 {
1323
1324                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1325                                   AFS_TRACE_LEVEL_VERBOSE_2,
1326                                   "AFSLocateNameEntry (FO: %p) Processing @SYS substitution for %wZ Index %08lX\n",
1327                                   FileObject,
1328                                   &uniComponentName,
1329                                   ulSubstituteIndex);
1330
1331                     ntStatus = AFSSubstituteSysName( &uniComponentName,
1332                                                      &uniSearchName,
1333                                                      ulSubstituteIndex);
1334
1335                     if ( NT_SUCCESS( ntStatus))
1336                     {
1337
1338                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1339                                       AFS_TRACE_LEVEL_VERBOSE_2,
1340                                       "AFSLocateNameEntry (FO: %p) Located substitution %wZ for %wZ Index %08lX\n",
1341                                       FileObject,
1342                                       &uniSearchName,
1343                                       &uniComponentName,
1344                                       ulSubstituteIndex);
1345
1346                         //
1347                         // Go reparse the name again
1348                         //
1349
1350                         bSubstituteName = TRUE;
1351
1352                         ulSubstituteIndex++; // For the next entry, if needed
1353
1354                         continue;   // while( pDirEntry == NULL)
1355                     }
1356                     else
1357                     {
1358
1359                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1360                                       AFS_TRACE_LEVEL_ERROR,
1361                                       "AFSLocateNameEntry (FO: %p) Failed to locate substitute string for %wZ Index %08lX Status %08lX\n",
1362                                       FileObject,
1363                                       &uniComponentName,
1364                                       ulSubstituteIndex,
1365                                       ntStatus);
1366
1367                         if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
1368                         {
1369
1370                             //
1371                             // Pass back the directory entries
1372                             //
1373
1374                             *ParentDirectoryCB = pParentDirEntry;
1375
1376                             *DirectoryCB = NULL;
1377
1378                             *VolumeCB = pCurrentVolume;
1379
1380                             if( ComponentName != NULL)
1381                             {
1382
1383                                 *ComponentName = uniComponentName;
1384                             }
1385
1386                             *RootPathName = uniFullPathName;
1387                         }
1388
1389                         //
1390                         // We can't possibly have a pDirEntry since the lookup failed
1391                         //
1392                         try_return( ntStatus);
1393                     }
1394                 }
1395
1396                 //
1397                 // Generate the CRC on the node and perform a case sensitive lookup
1398                 //
1399
1400                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1401                               AFS_TRACE_LEVEL_VERBOSE_2,
1402                               "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case sensitive\n",
1403                               FileObject,
1404                               &uniSearchName);
1405
1406                 ulCRC = AFSGenerateCRC( &uniSearchName,
1407                                         FALSE);
1408
1409                 AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1410                                   TRUE);
1411
1412                 AFSLocateCaseSensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
1413                                                 ulCRC,
1414                                                 &pDirEntry);
1415
1416                 if( pDirEntry == NULL)
1417                 {
1418
1419                     //
1420                     // Missed so perform a case insensitive lookup
1421                     //
1422
1423                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1424                                   AFS_TRACE_LEVEL_VERBOSE_2,
1425                                   "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case insensitive\n",
1426                                   FileObject,
1427                                   &uniSearchName);
1428
1429                     ulCRC = AFSGenerateCRC( &uniSearchName,
1430                                             TRUE);
1431
1432                     AFSLocateCaseInsensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
1433                                                       ulCRC,
1434                                                       &pDirEntry);
1435
1436                     if( pDirEntry == NULL)
1437                     {
1438
1439                         //
1440                         // OK, if this component is a valid short name then try
1441                         // a lookup in the short name tree
1442                         //
1443
1444                         if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
1445                             RtlIsNameLegalDOS8Dot3( &uniSearchName,
1446                                                     NULL,
1447                                                     NULL))
1448                         {
1449
1450                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1451                                           AFS_TRACE_LEVEL_VERBOSE_2,
1452                                           "AFSLocateNameEntry (FO: %p) Searching for entry %wZ short name\n",
1453                                           FileObject,
1454                                           &uniSearchName);
1455
1456                             AFSLocateShortNameDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.ShortNameTree,
1457                                                         ulCRC,
1458                                                         &pDirEntry);
1459                         }
1460
1461                         if ( pDirEntry == NULL &&
1462                              pParentDirEntry->ObjectInformation->VolumeCB == AFSGlobalRoot)
1463                         {
1464
1465                             //
1466                             // Check with the service to see if this is a valid cell name
1467                             // that can be automatically resolved.  Drop the shared TreeLock
1468                             // since AFSCheckCellName must acquire it exclusively.
1469                             //
1470
1471                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1472
1473                             ntStatus = AFSCheckCellName( AuthGroup,
1474                                                          &uniSearchName,
1475                                                          &pDirEntry);
1476
1477                             AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1478                                               TRUE);
1479                         }
1480
1481                         if( pDirEntry == NULL)
1482                         {
1483
1484                             //
1485                             // If we substituted a name then reset our search name and try again
1486                             //
1487
1488                             if( bSubstituteName)
1489                             {
1490
1491                                 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1492
1493                                 uniSearchName = uniComponentName;
1494
1495                                 bSubstituteName = FALSE;
1496
1497                                 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1498
1499                                 continue;       // while( pDirEntry == NULL)
1500                             }
1501
1502                             if( uniRemainingPath.Length > 0)
1503                             {
1504
1505                                 ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1506
1507                                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1508                                               AFS_TRACE_LEVEL_VERBOSE,
1509                                               "AFSLocateNameEntry (FO: %08lX) Returning path not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1510                                               FileObject,
1511                                               &uniSearchName,
1512                                               pCurrentObject->FileId.Cell,
1513                                               pCurrentObject->FileId.Volume,
1514                                               pCurrentObject->FileId.Vnode,
1515                                               pCurrentObject->FileId.Unique);
1516                             }
1517                             else
1518                             {
1519
1520                                 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
1521
1522                                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1523                                               AFS_TRACE_LEVEL_VERBOSE,
1524                                               "AFSLocateNameEntry (FO: %p) Returning name not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1525                                               FileObject,
1526                                               &uniSearchName,
1527                                               pCurrentObject->FileId.Cell,
1528                                               pCurrentObject->FileId.Volume,
1529                                               pCurrentObject->FileId.Vnode,
1530                                               pCurrentObject->FileId.Unique);
1531
1532                                 //
1533                                 // Pass back the directory entries
1534                                 //
1535
1536                                 *ParentDirectoryCB = pParentDirEntry;
1537
1538                                 *DirectoryCB = NULL;
1539
1540                                 *VolumeCB = pCurrentVolume;
1541
1542                                 if( ComponentName != NULL)
1543                                 {
1544
1545                                     *ComponentName = uniComponentName;
1546                                 }
1547
1548                                 *RootPathName = uniFullPathName;
1549                             }
1550
1551                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1552
1553                             //
1554                             // Node name not found so get out
1555                             //
1556
1557                             try_return( ntStatus);  // while( pDirEntry == NULL)
1558                         }
1559                     }
1560                     else
1561                     {
1562
1563                         //
1564                         // Here we have a match on the case insensitive lookup for the name. If there
1565                         // Is more than one link entry for this node then fail the lookup request
1566                         //
1567
1568                         if( !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD) ||
1569                             pDirEntry->CaseInsensitiveList.fLink != NULL)
1570                         {
1571
1572                             //
1573                             // Increment our dir entry ref count since we will decrement it on exit
1574                             //
1575
1576                             lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1577
1578                             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1579                                           AFS_TRACE_LEVEL_VERBOSE,
1580                                           "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
1581                                           &pDirEntry->NameInformation.FileName,
1582                                           pDirEntry,
1583                                           NULL,
1584                                           lCount);
1585
1586                             AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1587
1588                             try_return(ntStatus = STATUS_OBJECT_NAME_COLLISION);
1589                         }
1590                     }
1591                 }
1592
1593                 if( pDirEntry != NULL)
1594                 {
1595
1596                     //
1597                     // If the verify flag is set on the parent and the current entry is deleted
1598                     // revalidate the parent and search again.
1599                     //
1600
1601                     if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
1602                         BooleanFlagOn( pParentDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
1603                     {
1604
1605                         AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1606
1607                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1608                                       AFS_TRACE_LEVEL_VERBOSE,
1609                                       "AFSLocateNameEntry (FO: %p) Verifying(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1610                                       FileObject,
1611                                       &pParentDirEntry->NameInformation.FileName,
1612                                       pParentDirEntry->ObjectInformation->FileId.Cell,
1613                                       pParentDirEntry->ObjectInformation->FileId.Volume,
1614                                       pParentDirEntry->ObjectInformation->FileId.Vnode,
1615                                       pParentDirEntry->ObjectInformation->FileId.Unique);
1616
1617                         //
1618                         // Directory TreeLock should be exclusively held
1619                         //
1620
1621                         AFSAcquireExcl( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1622                                         TRUE);
1623
1624                         ntStatus = AFSVerifyEntry( AuthGroup,
1625                                                    pParentDirEntry);
1626
1627                         AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1628
1629                         if( !NT_SUCCESS( ntStatus))
1630                         {
1631
1632                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1633                                           AFS_TRACE_LEVEL_ERROR,
1634                                           "AFSLocateNameEntry (FO: %p) Failed to verify(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1635                                           FileObject,
1636                                           &pParentDirEntry->NameInformation.FileName,
1637                                           pParentDirEntry->ObjectInformation->FileId.Cell,
1638                                           pParentDirEntry->ObjectInformation->FileId.Volume,
1639                                           pParentDirEntry->ObjectInformation->FileId.Vnode,
1640                                           pParentDirEntry->ObjectInformation->FileId.Unique,
1641                                           ntStatus);
1642
1643                             try_return( ntStatus);
1644                         }
1645
1646                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1647                                       AFS_TRACE_LEVEL_VERBOSE,
1648                                       "AFSLocateNameEntry (FO: %p) Reprocessing component %wZ in parent %wZ\n",
1649                                       FileObject,
1650                                       &uniSearchName,
1651                                       &pParentDirEntry->NameInformation.FileName);
1652
1653
1654                         pDirEntry = NULL;
1655
1656                         continue;
1657                     }
1658
1659                     //
1660                     // Increment our dir entry ref count
1661                     //
1662
1663                     lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1664
1665                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1666                                   AFS_TRACE_LEVEL_VERBOSE,
1667                                   "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
1668                                   &pDirEntry->NameInformation.FileName,
1669                                   pDirEntry,
1670                                   NULL,
1671                                   lCount);
1672                 }
1673
1674                 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1675
1676             } // End while( pDirEntry == NULL)
1677
1678             //
1679             // If we have a dirEntry for this component, perform some basic validation on it
1680             //
1681
1682             if( pDirEntry != NULL &&
1683                 BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
1684             {
1685
1686                 pCurrentObject = pDirEntry->ObjectInformation;
1687
1688                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1689                               AFS_TRACE_LEVEL_ERROR,
1690                               "AFSLocateNameEntry (FO: %p) Deleted entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1691                               FileObject,
1692                               &pDirEntry->NameInformation.FileName,
1693                               pCurrentObject->FileId.Cell,
1694                               pCurrentObject->FileId.Volume,
1695                               pCurrentObject->FileId.Vnode,
1696                               pCurrentObject->FileId.Unique);
1697
1698                 //
1699                 // This entry was deleted through the invalidation call back so perform cleanup
1700                 // on the entry
1701                 //
1702
1703                 pParentObjectInfo = pCurrentObject->ParentObjectInformation;
1704
1705                 ASSERT( pParentObjectInfo != NULL);
1706
1707                 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
1708                                 TRUE);
1709
1710                 AFSAcquireExcl( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock,
1711                                 TRUE);
1712
1713                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1714
1715                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1716                               AFS_TRACE_LEVEL_VERBOSE,
1717                               "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1718                               &pDirEntry->NameInformation.FileName,
1719                               pDirEntry,
1720                               NULL,
1721                               lCount);
1722
1723                 ASSERT( lCount >= 0);
1724
1725                 if( lCount <= 0)
1726                 {
1727
1728                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING|AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1729                                   AFS_TRACE_LEVEL_VERBOSE,
1730                                   "AFSLocateNameEntry Deleting dir entry %p (%p) for %wZ\n",
1731                                   pDirEntry,
1732                                   pCurrentObject,
1733                                   &pDirEntry->NameInformation.FileName);
1734
1735                     //
1736                     // Remove and delete the directory entry from the parent list
1737                     //
1738
1739                     AFSDeleteDirEntry( pParentObjectInfo,
1740                                        pDirEntry);
1741
1742                     AFSAcquireShared( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
1743                                       TRUE);
1744
1745                     if( pCurrentObject->ObjectReferenceCount <= 0)
1746                     {
1747
1748                         if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
1749                         {
1750
1751                             AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1752                                           AFS_TRACE_LEVEL_VERBOSE,
1753                                           "AFSLocateNameEntry Removing object %p from volume tree\n",
1754                                           pCurrentObject);
1755
1756                             AFSRemoveHashEntry( &pCurrentObject->VolumeCB->ObjectInfoTree.TreeHead,
1757                                                 &pCurrentObject->TreeEntry);
1758
1759                             ClearFlag( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
1760                         }
1761                     }
1762
1763                     AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1764                 }
1765                 else
1766                 {
1767
1768                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1769                                   AFS_TRACE_LEVEL_VERBOSE,
1770                                   "AFSLocateNameEntry Setting DELETE flag in dir entry %p for %wZ\n",
1771                                   pDirEntry,
1772                                   &pDirEntry->NameInformation.FileName);
1773
1774                     SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
1775
1776                     AFSRemoveNameEntry( pParentObjectInfo,
1777                                         pDirEntry);
1778                 }
1779
1780                 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
1781
1782                 AFSReleaseResource( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock);
1783
1784                 //
1785                 // We deleted the dir entry so check if there is any remaining portion
1786                 // of the name to process.
1787                 //
1788
1789                 if( uniRemainingPath.Length > 0)
1790                 {
1791
1792                     ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1793
1794                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1795                                   AFS_TRACE_LEVEL_VERBOSE,
1796                                   "AFSLocateNameEntry (FO: %08lX) Returning path not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1797                                   FileObject,
1798                                   &uniComponentName,
1799                                   pCurrentObject->FileId.Cell,
1800                                   pCurrentObject->FileId.Volume,
1801                                   pCurrentObject->FileId.Vnode,
1802                                   pCurrentObject->FileId.Unique);
1803                 }
1804                 else
1805                 {
1806
1807                     ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
1808
1809                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1810                                   AFS_TRACE_LEVEL_VERBOSE,
1811                                   "AFSLocateNameEntry (FO: %p) Returning name not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1812                                   FileObject,
1813                                   &uniComponentName,
1814                                   pCurrentObject->FileId.Cell,
1815                                   pCurrentObject->FileId.Volume,
1816                                   pCurrentObject->FileId.Vnode,
1817                                   pCurrentObject->FileId.Unique);
1818
1819                     //
1820                     // Pass back the directory entries
1821                     //
1822
1823                     *ParentDirectoryCB = pParentDirEntry;
1824
1825                     *DirectoryCB = NULL;
1826
1827                     *VolumeCB = pCurrentVolume;
1828
1829                     if( ComponentName != NULL)
1830                     {
1831
1832                         *ComponentName = uniComponentName;
1833                     }
1834
1835                     *RootPathName = uniFullPathName;
1836                 }
1837             }
1838
1839             if( ntStatus != STATUS_SUCCESS)
1840             {
1841
1842                 try_return( ntStatus);
1843             }
1844
1845             //
1846             // Decrement the previous parent
1847             //
1848
1849             lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
1850
1851             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1852                           AFS_TRACE_LEVEL_VERBOSE,
1853                           "AFSLocateNameEntry Decrement5 count on Parent %wZ DE %p Ccb %p Cnt %d\n",
1854                           &pParentDirEntry->NameInformation.FileName,
1855                           pParentDirEntry,
1856                           NULL,
1857                           lCount);
1858
1859             ASSERT( lCount >= 0);
1860
1861             //
1862             // If we ended up substituting a name in the component then update
1863             // the full path and update the pointers
1864             //
1865
1866             if( bSubstituteName)
1867             {
1868
1869                 BOOLEAN bRelativeOpen = FALSE;
1870
1871                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1872                               AFS_TRACE_LEVEL_VERBOSE_2,
1873                               "AFSLocateNameEntry (FO: %p) Substituting %wZ into %wZ Index %08lX\n",
1874                               FileObject,
1875                               &uniSearchName,
1876                               &uniComponentName,
1877                               ulSubstituteIndex);
1878
1879                 if( FileObject != NULL &&
1880                     FileObject->RelatedFileObject != NULL)
1881                 {
1882
1883                     bRelativeOpen = TRUE;
1884                 }
1885
1886                 //
1887                 // AFSSubstituteNameInPath will replace the uniFullPathName.Buffer
1888                 // and free the prior Buffer contents but only if the fourth
1889                 // parameter is TRUE.
1890                 //
1891
1892                 ntStatus = AFSSubstituteNameInPath( &uniFullPathName,
1893                                                     &uniComponentName,
1894                                                     &uniSearchName,
1895                                                     &uniRemainingPath,
1896                                                     bRelativeOpen ||
1897                                                             bAllocatedSymLinkBuffer ||
1898                                                             bSubstitutedName);
1899
1900                 if( !NT_SUCCESS( ntStatus))
1901                 {
1902
1903                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1904                                   AFS_TRACE_LEVEL_ERROR,
1905                                   "AFSLocateNameEntry (FO: %p) Failure to substitute %wZ into %wZ Index %08lX Status %08lX\n",
1906                                   FileObject,
1907                                   &uniSearchName,
1908                                   &uniComponentName,
1909                                   ulSubstituteIndex,
1910                                   ntStatus);
1911
1912                     try_return( ntStatus);
1913                 }
1914
1915                 //
1916                 // We have substituted a name into the buffer so if we do this again for this
1917                 // path, we need to free up the buffer we allocated.
1918                 //
1919
1920                 bSubstitutedName = TRUE;
1921             }
1922
1923             //
1924             // Update the search parameters
1925             //
1926
1927             uniPathName = uniRemainingPath;
1928
1929             //
1930             // Check if the is a SymLink entry but has no Target FileID or Name. In this
1931             // case it might be a DFS Link so let's go and evaluate it to be sure
1932             //
1933
1934             if( pCurrentObject->FileType == AFS_FILE_TYPE_SYMLINK &&
1935                 ( pCurrentObject->TargetFileId.Vnode == 0 ||
1936                   pDirEntry->NameInformation.TargetName.Length == 0))
1937             {
1938
1939                 ntStatus = AFSValidateSymLink( AuthGroup,
1940                                                pDirEntry);
1941
1942                 if( !NT_SUCCESS( ntStatus))
1943                 {
1944
1945                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1946                                   AFS_TRACE_LEVEL_ERROR,
1947                                   "AFSLocateNameEntry (FO: %p) Failed to evaluate possible DFS Link %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1948                                   FileObject,
1949                                   &pDirEntry->NameInformation.FileName,
1950                                   pCurrentObject->FileId.Cell,
1951                                   pCurrentObject->FileId.Volume,
1952                                   pCurrentObject->FileId.Vnode,
1953                                   pCurrentObject->FileId.Unique,
1954                                   ntStatus);
1955
1956                     try_return( ntStatus);
1957                 }
1958             }
1959
1960             //
1961             // Update the name array
1962             //
1963
1964             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1965                           AFS_TRACE_LEVEL_VERBOSE,
1966                           "AFSLocateNameEntry (FO: %p) Inserting name array entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1967                           FileObject,
1968                           &pDirEntry->NameInformation.FileName,
1969                           pCurrentObject->FileId.Cell,
1970                           pCurrentObject->FileId.Volume,
1971                           pCurrentObject->FileId.Vnode,
1972                           pCurrentObject->FileId.Unique);
1973
1974             ntStatus = AFSInsertNextElement( pNameArray,
1975                                              pDirEntry);
1976
1977             if( !NT_SUCCESS( ntStatus))
1978             {
1979
1980                 try_return( ntStatus);
1981             }
1982         }       // while (TRUE)
1983
1984 try_exit:
1985
1986         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1987                       AFS_TRACE_LEVEL_VERBOSE,
1988                       "AFSLocateNameEntry (FO: %p) Completed processing %wZ Status %08lX\n",
1989                       FileObject,
1990                       RootPathName,
1991                       ntStatus);
1992
1993         if( ( !NT_SUCCESS( ntStatus) &&
1994               ntStatus != STATUS_OBJECT_NAME_NOT_FOUND) ||
1995             ntStatus == STATUS_REPARSE)
1996         {
1997
1998             if( pDirEntry != NULL)
1999             {
2000
2001                 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
2002
2003                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2004                               AFS_TRACE_LEVEL_VERBOSE,
2005                               "AFSLocateNameEntry Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
2006                               &pDirEntry->NameInformation.FileName,
2007                               pDirEntry,
2008                               NULL,
2009                               lCount);
2010
2011                 ASSERT( lCount >= 0);
2012             }
2013             else if( pParentDirEntry != NULL)
2014             {
2015
2016                 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
2017
2018                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2019                               AFS_TRACE_LEVEL_VERBOSE,
2020                               "AFSLocateNameEntry Decrement7 count on %wZ DE %p Ccb %p Cnt %d\n",
2021                               &pParentDirEntry->NameInformation.FileName,
2022                               pParentDirEntry,
2023                               NULL,
2024                               lCount);
2025
2026                 ASSERT( lCount >= 0);
2027             }
2028
2029             if( bReleaseCurrentVolume)
2030             {
2031
2032                 ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
2033
2034                 lCount = InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
2035
2036                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
2037                               AFS_TRACE_LEVEL_VERBOSE,
2038                               "AFSLocateNameEntry Decrement3 count on volume %p Cnt %d\n",
2039                               pCurrentVolume,
2040                               lCount);
2041             }
2042
2043             if( RootPathName->Buffer != uniFullPathName.Buffer)
2044             {
2045
2046                 AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
2047             }
2048         }
2049         else
2050         {
2051
2052             if( *ParentDirectoryCB != NULL)
2053             {
2054
2055                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2056                               AFS_TRACE_LEVEL_VERBOSE,
2057                               "AFSLocateNameEntry Count on Parent %wZ DE %p Ccb %p Cnt %d\n",
2058                               &(*ParentDirectoryCB)->NameInformation.FileName,
2059                               *ParentDirectoryCB,
2060                               NULL,
2061                               (*ParentDirectoryCB)->DirOpenReferenceCount);
2062             }
2063
2064             if( *DirectoryCB != NULL)
2065             {
2066
2067                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2068                               AFS_TRACE_LEVEL_VERBOSE,
2069                               "AFSLocateNameEntry Count on %wZ DE %p Ccb %p Cnt %d\n",
2070                               &(*DirectoryCB)->NameInformation.FileName,
2071                               *DirectoryCB,
2072                               NULL,
2073                               (*DirectoryCB)->DirOpenReferenceCount);
2074             }
2075         }
2076
2077         if( bSubstituteName &&
2078             uniSearchName.Buffer != NULL)
2079         {
2080
2081             AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
2082         }
2083     }
2084
2085     return ntStatus;
2086 }
2087
2088 NTSTATUS
2089 AFSCreateDirEntry( IN GUID            *AuthGroup,
2090                    IN AFSObjectInfoCB *ParentObjectInfo,
2091                    IN AFSDirectoryCB *ParentDirCB,
2092                    IN PUNICODE_STRING FileName,
2093                    IN PUNICODE_STRING ComponentName,
2094                    IN ULONG Attributes,
2095                    IN OUT AFSDirectoryCB **DirEntry)
2096 {
2097
2098     UNREFERENCED_PARAMETER(FileName);
2099     NTSTATUS ntStatus = STATUS_SUCCESS;
2100     AFSDirectoryCB *pDirNode = NULL, *pExistingDirNode = NULL;
2101     LARGE_INTEGER liFileSize = {0,0};
2102     LONG lCount;
2103
2104     __Enter
2105     {
2106
2107         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2108                       AFS_TRACE_LEVEL_VERBOSE_2,
2109                       "AFSCreateDirEntry Creating dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX\n",
2110                       &ParentDirCB->NameInformation.FileName,
2111                       ParentObjectInfo->FileId.Cell,
2112                       ParentObjectInfo->FileId.Volume,
2113                       ParentObjectInfo->FileId.Vnode,
2114                       ParentObjectInfo->FileId.Unique,
2115                       ComponentName,
2116                       Attributes);
2117
2118         //
2119         // OK, before inserting the node into the parent tree, issue
2120         // the request to the service for node creation
2121         // We will need to drop the lock on the parent node since the create
2122         // could cause a callback into the file system to invalidate it's cache
2123         //
2124
2125         ntStatus = AFSNotifyFileCreate( AuthGroup,
2126                                         ParentObjectInfo,
2127                                         &liFileSize,
2128                                         Attributes,
2129                                         ComponentName,
2130                                         &pDirNode);
2131
2132         //
2133         // If the returned status is STATUS_REPARSE then the entry exists
2134         // and we raced, get out.
2135
2136         if( ntStatus == STATUS_REPARSE)
2137         {
2138
2139             *DirEntry = pDirNode;
2140
2141             try_return( ntStatus = STATUS_SUCCESS);
2142         }
2143
2144         if( !NT_SUCCESS( ntStatus))
2145         {
2146
2147             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2148                           AFS_TRACE_LEVEL_ERROR,
2149                           "AFSCreateDirEntry Failed to create dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX Status %08lX\n",
2150                           &ParentDirCB->NameInformation.FileName,
2151                           ParentObjectInfo->FileId.Cell,
2152                           ParentObjectInfo->FileId.Volume,
2153                           ParentObjectInfo->FileId.Vnode,
2154                           ParentObjectInfo->FileId.Unique,
2155                           ComponentName,
2156                           Attributes,
2157                           ntStatus);
2158
2159             try_return( ntStatus);
2160         }
2161
2162         //
2163         // If AFSNotifyFileCreate returns pDirNode != NULL, then its
2164         // DirOpenReferenceCount is held.
2165         //
2166
2167         AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2168                         TRUE);
2169
2170         //
2171         // Before attempting to insert the new entry, check if we need to validate the parent
2172         //
2173
2174         if( BooleanFlagOn( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
2175         {
2176
2177             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2178                           AFS_TRACE_LEVEL_VERBOSE,
2179                           "AFSCreateDirEntry Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2180                           &ParentDirCB->NameInformation.FileName,
2181                           ParentObjectInfo->FileId.Cell,
2182                           ParentObjectInfo->FileId.Volume,
2183                           ParentObjectInfo->FileId.Vnode,
2184                           ParentObjectInfo->FileId.Unique);
2185
2186             ntStatus = AFSVerifyEntry( AuthGroup,
2187                                        ParentDirCB);
2188
2189             if( !NT_SUCCESS( ntStatus))
2190             {
2191
2192                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2193                               AFS_TRACE_LEVEL_ERROR,
2194                               "AFSCreateDirEntry Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2195                               &ParentDirCB->NameInformation.FileName,
2196                               ParentObjectInfo->FileId.Cell,
2197                               ParentObjectInfo->FileId.Volume,
2198                               ParentObjectInfo->FileId.Vnode,
2199                               ParentObjectInfo->FileId.Unique,
2200                               ntStatus);
2201
2202                 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2203
2204                 try_return( ntStatus);
2205             }
2206         }
2207
2208         //
2209         // Check for the entry in the event we raced with some other thread
2210         //
2211
2212         AFSLocateCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2213                                         (ULONG)pDirNode->CaseSensitiveTreeEntry.HashIndex,
2214                                         &pExistingDirNode);
2215
2216         if( pExistingDirNode != NULL)
2217         {
2218             if (AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
2219                                &pExistingDirNode->ObjectInformation->FileId))
2220             {
2221
2222                 if ( pExistingDirNode != pDirNode)
2223                 {
2224
2225                     lCount = InterlockedDecrement( &pDirNode->DirOpenReferenceCount);
2226
2227                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2228                                   AFS_TRACE_LEVEL_VERBOSE,
2229                                   "AFSCreateDirEntry Decrement count on %wZ DE %p Cnt %d\n",
2230                                   &pDirNode->NameInformation.FileName,
2231                                   pDirNode,
2232                                   lCount);
2233
2234                     AFSDeleteDirEntry( ParentObjectInfo,
2235                                        pDirNode);
2236
2237                     lCount = InterlockedIncrement( &pExistingDirNode->DirOpenReferenceCount);
2238
2239                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2240                                   AFS_TRACE_LEVEL_VERBOSE,
2241                                   "AFSCreateDirEntry Increment count on %wZ DE %p Cnt %d\n",
2242                                   &pExistingDirNode->NameInformation.FileName,
2243                                   pExistingDirNode,
2244                                   lCount);
2245
2246                     *DirEntry = pExistingDirNode;
2247                 }
2248
2249                 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2250
2251                 try_return( ntStatus = STATUS_SUCCESS);
2252             }
2253             else
2254             {
2255
2256                 //
2257                 // Need to tear down this entry and rebuild it below
2258                 //
2259
2260                 if( pExistingDirNode->DirOpenReferenceCount <= 0)
2261                 {
2262
2263                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2264                                   AFS_TRACE_LEVEL_VERBOSE,
2265                                   "AFSCreateDirEntry Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2266                                   pExistingDirNode,
2267                                   &pExistingDirNode->NameInformation.FileName,
2268                                   pExistingDirNode->ObjectInformation->FileId.Cell,
2269                                   pExistingDirNode->ObjectInformation->FileId.Volume,
2270                                   pExistingDirNode->ObjectInformation->FileId.Vnode,
2271                                   pExistingDirNode->ObjectInformation->FileId.Unique,
2272                                   pDirNode->ObjectInformation->FileId.Cell,
2273                                   pDirNode->ObjectInformation->FileId.Volume,
2274                                   pDirNode->ObjectInformation->FileId.Vnode,
2275                                   pDirNode->ObjectInformation->FileId.Unique);
2276
2277                     AFSDeleteDirEntry( ParentObjectInfo,
2278                                        pExistingDirNode);
2279                 }
2280                 else
2281                 {
2282
2283                     SetFlag( pExistingDirNode->Flags, AFS_DIR_ENTRY_DELETED);
2284
2285                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2286                                   AFS_TRACE_LEVEL_VERBOSE,
2287                                   "AFSCreateDirEntry Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2288                                   pExistingDirNode,
2289                                   &pExistingDirNode->NameInformation.FileName,
2290                                   pExistingDirNode->ObjectInformation->FileId.Cell,
2291                                   pExistingDirNode->ObjectInformation->FileId.Volume,
2292                                   pExistingDirNode->ObjectInformation->FileId.Vnode,
2293                                   pExistingDirNode->ObjectInformation->FileId.Unique,
2294                                   pDirNode->ObjectInformation->FileId.Cell,
2295                                   pDirNode->ObjectInformation->FileId.Volume,
2296                                   pDirNode->ObjectInformation->FileId.Vnode,
2297                                   pDirNode->ObjectInformation->FileId.Unique);
2298
2299                     AFSRemoveNameEntry( ParentObjectInfo,
2300                                         pExistingDirNode);
2301                 }
2302             }
2303         }
2304
2305         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2306                       AFS_TRACE_LEVEL_VERBOSE_2,
2307                       "AFSCreateDirEntry Inserting dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ\n",
2308                       &ParentDirCB->NameInformation.FileName,
2309                       ParentObjectInfo->FileId.Cell,
2310                       ParentObjectInfo->FileId.Volume,
2311                       ParentObjectInfo->FileId.Vnode,
2312                       ParentObjectInfo->FileId.Unique,
2313                       ComponentName);
2314
2315         //
2316         // Insert the directory node
2317         //
2318
2319         AFSInsertDirectoryNode( ParentObjectInfo,
2320                                 pDirNode,
2321                                 TRUE);
2322
2323         //
2324         // Pass back the dir entry
2325         //
2326
2327         *DirEntry = pDirNode;
2328
2329         AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2330
2331 try_exit:
2332
2333         NOTHING;
2334     }
2335
2336     return ntStatus;
2337 }
2338
2339 void
2340 AFSInsertDirectoryNode( IN AFSObjectInfoCB *ParentObjectInfo,
2341                         IN AFSDirectoryCB *DirEntry,
2342                         IN BOOLEAN InsertInEnumList)
2343 {
2344
2345     LONG lCount;
2346
2347     __Enter
2348     {
2349
2350         ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2351
2352         //
2353         // Insert the node into the directory node tree
2354         //
2355
2356         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2357                       AFS_TRACE_LEVEL_VERBOSE,
2358                       "AFSInsertDirectoryNode Insert DE %p for %wZ Clearing NOT_IN flag\n",
2359                       DirEntry,
2360                       &DirEntry->NameInformation.FileName);
2361
2362         ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
2363
2364         if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead == NULL)
2365         {
2366
2367             ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = DirEntry;
2368
2369             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2370                           AFS_TRACE_LEVEL_VERBOSE,
2371                           "AFSInsertDirectoryNode Insert DE %p to head of case sensitive tree for %wZ\n",
2372                           DirEntry,
2373                           &DirEntry->NameInformation.FileName);
2374         }
2375         else
2376         {
2377
2378             AFSInsertCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2379                                             DirEntry);
2380
2381             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2382                           AFS_TRACE_LEVEL_VERBOSE,
2383                           "AFSInsertDirectoryNode Insert DE %p to case sensitive tree for %wZ\n",
2384                           DirEntry,
2385                           &DirEntry->NameInformation.FileName);
2386         }
2387
2388         if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead == NULL)
2389         {
2390
2391             ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = DirEntry;
2392
2393             SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
2394
2395             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2396                           AFS_TRACE_LEVEL_VERBOSE,
2397                           "AFSInsertDirectoryNode Insert DE %p to head of case insensitive tree for %wZ\n",
2398                           DirEntry,
2399                           &DirEntry->NameInformation.FileName);
2400         }
2401         else
2402         {
2403
2404             AFSInsertCaseInsensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2405                                               DirEntry);
2406
2407             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2408                           AFS_TRACE_LEVEL_VERBOSE,
2409                           "AFSInsertDirectoryNode Insert DE %p to case insensitive tree for %wZ\n",
2410                           DirEntry,
2411                           &DirEntry->NameInformation.FileName);
2412         }
2413
2414         //
2415         // Into the shortname tree
2416         //
2417
2418         if( DirEntry->Type.Data.ShortNameTreeEntry.HashIndex != 0)
2419         {
2420
2421             if( ParentObjectInfo->Specific.Directory.ShortNameTree == NULL)
2422             {
2423
2424                 ParentObjectInfo->Specific.Directory.ShortNameTree = DirEntry;
2425
2426                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2427                               AFS_TRACE_LEVEL_VERBOSE,
2428                               "AFSInsertDirectoryNode Insert DE %p to head of shortname tree for %wZ\n",
2429                               DirEntry,
2430                               &DirEntry->NameInformation.FileName);
2431
2432                 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2433             }
2434             else
2435             {
2436
2437                 if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ParentObjectInfo->Specific.Directory.ShortNameTree,
2438                                                              DirEntry)))
2439                 {
2440                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2441                                   AFS_TRACE_LEVEL_VERBOSE,
2442                                   "AFSInsertDirectoryNode Failed to insert DE %p to shortname tree for %wZ\n",
2443                                   DirEntry,
2444                                   &DirEntry->NameInformation.FileName);
2445                 }
2446                 else
2447                 {
2448                     SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2449
2450                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2451                                   AFS_TRACE_LEVEL_VERBOSE,
2452                                   "AFSInsertDirectoryNode Insert DE %p to shortname tree for %wZ\n",
2453                                   DirEntry,
2454                                   &DirEntry->NameInformation.FileName);
2455                 }
2456             }
2457         }
2458
2459         if( InsertInEnumList)
2460         {
2461
2462             //
2463             // And insert the node into the directory list
2464             //
2465
2466             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2467                           AFS_TRACE_LEVEL_VERBOSE,
2468                           "AFSInsertDirectoryNode Inserting entry %p %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2469                           DirEntry,
2470                           &DirEntry->NameInformation.FileName,
2471                           DirEntry->ObjectInformation->FileId.Cell,
2472                           DirEntry->ObjectInformation->FileId.Volume,
2473                           DirEntry->ObjectInformation->FileId.Vnode,
2474                           DirEntry->ObjectInformation->FileId.Unique);
2475
2476             if( ParentObjectInfo->Specific.Directory.DirectoryNodeListHead == NULL)
2477             {
2478
2479                 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = DirEntry;
2480             }
2481             else
2482             {
2483
2484                 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail->ListEntry.fLink = (void *)DirEntry;
2485
2486                 DirEntry->ListEntry.bLink = (void *)ParentObjectInfo->Specific.Directory.DirectoryNodeListTail;
2487             }
2488
2489             ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = DirEntry;
2490
2491             SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2492
2493             lCount = InterlockedIncrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2494
2495             AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2496                           AFS_TRACE_LEVEL_VERBOSE,
2497                           "AFSInsertDirectoryNode Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2498                           &DirEntry->NameInformation.FileName,
2499                           lCount,
2500                           ParentObjectInfo->FileId.Cell,
2501                           ParentObjectInfo->FileId.Volume,
2502                           ParentObjectInfo->FileId.Vnode,
2503                           ParentObjectInfo->FileId.Unique);
2504         }
2505     }
2506
2507     return;
2508 }
2509
2510 NTSTATUS
2511 AFSDeleteDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
2512                    IN AFSDirectoryCB *DirEntry)
2513 {
2514
2515     NTSTATUS ntStatus = STATUS_SUCCESS;
2516     LONG lCount;
2517
2518     __Enter
2519     {
2520
2521         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2522                       AFS_TRACE_LEVEL_VERBOSE,
2523                       "AFSDeleteDirEntry Deleting dir entry in parent %08lX Entry %p %wZ FID %08lX-%08lX-%08lX-%08lX RefCount %d\n",
2524                       ParentObjectInfo,
2525                       DirEntry,
2526                       &DirEntry->NameInformation.FileName,
2527                       DirEntry->ObjectInformation->FileId.Cell,
2528                       DirEntry->ObjectInformation->FileId.Volume,
2529                       DirEntry->ObjectInformation->FileId.Vnode,
2530                       DirEntry->ObjectInformation->FileId.Unique,
2531                       DirEntry->DirOpenReferenceCount);
2532
2533         ASSERT( DirEntry->DirOpenReferenceCount == 0);
2534
2535         AFSRemoveDirNodeFromParent( ParentObjectInfo,
2536                                     DirEntry,
2537                                     TRUE);
2538
2539         //
2540         // Free up the name buffer if it was reallocated
2541         //
2542
2543         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
2544         {
2545
2546             AFSExFreePoolWithTag( DirEntry->NameInformation.FileName.Buffer, 0);
2547         }
2548
2549         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
2550         {
2551
2552             AFSExFreePoolWithTag( DirEntry->NameInformation.TargetName.Buffer, 0);
2553         }
2554
2555         //
2556         // Dereference the object for this dir entry
2557         //
2558
2559         lCount = AFSObjectInfoDecrement( DirEntry->ObjectInformation,
2560                                          AFS_OBJECT_REFERENCE_DIRENTRY);
2561
2562         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2563                       AFS_TRACE_LEVEL_VERBOSE,
2564                       "AFSDeleteDirEntry Decrement count on object %p Cnt %d\n",
2565                       DirEntry->ObjectInformation,
2566                       lCount);
2567
2568         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_DELETED) &&
2569             DirEntry->ObjectInformation->Links == 0)
2570         {
2571
2572             SetFlag( DirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED);
2573         }
2574
2575         ExDeleteResourceLite( &DirEntry->NonPaged->Lock);
2576
2577         AFSExFreePoolWithTag( DirEntry->NonPaged, AFS_DIR_ENTRY_NP_TAG);
2578
2579         //
2580         // Free up the dir entry
2581         //
2582
2583         AFSExFreePoolWithTag( DirEntry, AFS_DIR_ENTRY_TAG);
2584     }
2585
2586     return ntStatus;
2587 }
2588
2589 NTSTATUS
2590 AFSRemoveDirNodeFromParent( IN AFSObjectInfoCB *ParentObjectInfo,
2591                             IN AFSDirectoryCB *DirEntry,
2592                             IN BOOLEAN RemoveFromEnumList)
2593 {
2594
2595     NTSTATUS ntStatus = STATUS_SUCCESS;
2596     LONG lCount;
2597
2598     __Enter
2599     {
2600
2601
2602         ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2603
2604         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2605                       AFS_TRACE_LEVEL_VERBOSE,
2606                       "AFSRemoveDirNodeFromParent Removing DirEntry %p %wZ FID %08lX-%08lX-%08lX-%08lX from Parent %p\n",
2607                       DirEntry,
2608                       &DirEntry->NameInformation.FileName,
2609                       DirEntry->ObjectInformation->FileId.Cell,
2610                       DirEntry->ObjectInformation->FileId.Volume,
2611                       DirEntry->ObjectInformation->FileId.Vnode,
2612                       DirEntry->ObjectInformation->FileId.Unique,
2613                       ParentObjectInfo);
2614
2615         if( !BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
2616         {
2617
2618             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2619                           AFS_TRACE_LEVEL_VERBOSE,
2620                           "AFSRemoveDirNodeFromParent Removing DirEntry %p name %wZ\n",
2621                           DirEntry,
2622                           &DirEntry->NameInformation.FileName);
2623
2624             AFSRemoveNameEntry( ParentObjectInfo,
2625                                 DirEntry);
2626         }
2627         else
2628         {
2629
2630             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2631                           AFS_TRACE_LEVEL_VERBOSE,
2632                           "AFSRemoveDirNodeFromParent DE %p for %wZ NOT removing entry due to flag set\n",
2633                           DirEntry,
2634                           &DirEntry->NameInformation.FileName);
2635
2636         }
2637
2638         if( RemoveFromEnumList &&
2639             BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST))
2640         {
2641
2642             //
2643             // And remove the entry from the enumeration list
2644             //
2645
2646             if( DirEntry->ListEntry.fLink == NULL)
2647             {
2648
2649                 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = (AFSDirectoryCB *)DirEntry->ListEntry.bLink;
2650             }
2651             else
2652             {
2653
2654                 ((AFSDirectoryCB *)DirEntry->ListEntry.fLink)->ListEntry.bLink = DirEntry->ListEntry.bLink;
2655             }
2656
2657             if( DirEntry->ListEntry.bLink == NULL)
2658             {
2659
2660                 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = (AFSDirectoryCB *)DirEntry->ListEntry.fLink;
2661             }
2662             else
2663             {
2664
2665                 ((AFSDirectoryCB *)DirEntry->ListEntry.bLink)->ListEntry.fLink = DirEntry->ListEntry.fLink;
2666             }
2667
2668             ASSERT( ParentObjectInfo->Specific.Directory.DirectoryNodeCount > 0);
2669
2670             lCount = InterlockedDecrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2671
2672             ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2673
2674             AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2675                           AFS_TRACE_LEVEL_VERBOSE,
2676                           "AFSRemoveDirNodeFromParent Removing entry %wZ Dec Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2677                           &DirEntry->NameInformation.FileName,
2678                           lCount,
2679                           ParentObjectInfo->FileId.Cell,
2680                           ParentObjectInfo->FileId.Volume,
2681                           ParentObjectInfo->FileId.Vnode,
2682                           ParentObjectInfo->FileId.Unique);
2683
2684             DirEntry->ListEntry.fLink = NULL;
2685             DirEntry->ListEntry.bLink = NULL;
2686         }
2687     }
2688
2689     return ntStatus;
2690 }
2691
2692 NTSTATUS
2693 AFSFixupTargetName( IN OUT PUNICODE_STRING FileName,
2694                     IN OUT PUNICODE_STRING TargetFileName)
2695 {
2696
2697     NTSTATUS ntStatus = STATUS_SUCCESS;
2698     UNICODE_STRING uniFileName;
2699
2700     __Enter
2701     {
2702
2703         //
2704         // We will process backwards from the end of the name looking
2705         // for the first \ we encounter
2706         //
2707
2708         uniFileName.Length = FileName->Length;
2709         uniFileName.MaximumLength = FileName->MaximumLength;
2710
2711         uniFileName.Buffer = FileName->Buffer;
2712
2713         while( TRUE)
2714         {
2715
2716             if( uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
2717             {
2718
2719                 //
2720                 // Subtract one more character off of the filename if it is not the root
2721                 //
2722
2723                 if( uniFileName.Length > sizeof( WCHAR))
2724                 {
2725
2726                     uniFileName.Length -= sizeof( WCHAR);
2727                 }
2728
2729                 //
2730                 // Now build up the target name
2731                 //
2732
2733                 TargetFileName->Length = FileName->Length - uniFileName.Length;
2734
2735                 //
2736                 // If we are not on the root then fixup the name
2737                 //
2738
2739                 if( uniFileName.Length > sizeof( WCHAR))
2740                 {
2741
2742                     TargetFileName->Length -= sizeof( WCHAR);
2743
2744                     TargetFileName->Buffer = &uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) + 1];
2745                 }
2746                 else
2747                 {
2748
2749                     TargetFileName->Buffer = &uniFileName.Buffer[ uniFileName.Length/sizeof( WCHAR)];
2750                 }
2751
2752                 //
2753                 // Fixup the passed back filename length
2754                 //
2755
2756                 FileName->Length = uniFileName.Length;
2757
2758                 TargetFileName->MaximumLength = TargetFileName->Length;
2759
2760                 break;
2761             }
2762
2763             uniFileName.Length -= sizeof( WCHAR);
2764         }
2765     }
2766
2767     return ntStatus;
2768 }
2769
2770 NTSTATUS
2771 AFSParseName( IN PIRP Irp,
2772               IN GUID *AuthGroup,
2773               OUT PUNICODE_STRING FileName,
2774               OUT PUNICODE_STRING ParsedFileName,
2775               OUT PUNICODE_STRING RootFileName,
2776               OUT ULONG *ParseFlags,
2777               OUT AFSVolumeCB   **VolumeCB,
2778               OUT AFSDirectoryCB **ParentDirectoryCB,
2779               OUT AFSNameArrayHdr **NameArray)
2780 {
2781
2782     NTSTATUS            ntStatus = STATUS_SUCCESS;
2783     PIO_STACK_LOCATION  pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2784     AFSDeviceExt       *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2785     UNICODE_STRING      uniFullName, uniComponentName, uniRemainingPath;
2786     ULONG               ulCRC = 0;
2787     AFSDirectoryCB     *pDirEntry = NULL;
2788     USHORT              usIndex = 0, usDriveIndex = 0;
2789     AFSCcb             *pRelatedCcb = NULL;
2790     AFSNameArrayHdr    *pNameArray = NULL, *pRelatedNameArray = NULL;
2791     USHORT              usComponentIndex = 0;
2792     USHORT              usComponentLength = 0;
2793     AFSVolumeCB        *pVolumeCB = NULL;
2794     AFSFcb             *pRelatedFcb = NULL;
2795     BOOLEAN             bReleaseTreeLock = FALSE;
2796     BOOLEAN             bIsAllShare = FALSE;
2797     LONG                lCount;
2798
2799     __Enter
2800     {
2801
2802         //
2803         // Indicate we are opening a root ...
2804         //
2805
2806         *ParseFlags = AFS_PARSE_FLAG_ROOT_ACCESS;
2807
2808         *ParentDirectoryCB = NULL;
2809
2810         if( pIrpSp->FileObject->RelatedFileObject != NULL)
2811         {
2812
2813             pRelatedFcb = (AFSFcb *)pIrpSp->FileObject->RelatedFileObject->FsContext;
2814
2815             pRelatedCcb = (AFSCcb *)pIrpSp->FileObject->RelatedFileObject->FsContext2;
2816
2817             pRelatedNameArray = pRelatedCcb->NameArray;
2818
2819             uniFullName = pIrpSp->FileObject->FileName;
2820
2821             ASSERT( pRelatedFcb != NULL);
2822
2823             //
2824             // No wild cards in the name
2825             //
2826
2827             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2828                           AFS_TRACE_LEVEL_VERBOSE_2,
2829                           "AFSParseName (%p) Relative open for %wZ FID %08lX-%08lX-%08lX-%08lX component %wZ\n",
2830                           Irp,
2831                           &pRelatedCcb->DirectoryCB->NameInformation.FileName,
2832                           pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Cell,
2833                           pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Volume,
2834                           pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
2835                           pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Unique,
2836                           &uniFullName);
2837
2838             if( FsRtlDoesNameContainWildCards( &uniFullName))
2839             {
2840
2841                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2842                               AFS_TRACE_LEVEL_ERROR,
2843                               "AFSParseName (%p) Component %wZ contains wild cards\n",
2844                               Irp,
2845                               &uniFullName);
2846
2847                 try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
2848             }
2849
2850             pVolumeCB = pRelatedFcb->ObjectInformation->VolumeCB;
2851
2852             pDirEntry = pRelatedCcb->DirectoryCB;
2853
2854             *FileName = pIrpSp->FileObject->FileName;
2855
2856             //
2857             // Grab the root node while checking state
2858             //
2859
2860             AFSAcquireShared( pVolumeCB->VolumeLock,
2861                               TRUE);
2862
2863             if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
2864                 BooleanFlagOn( pVolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE))
2865             {
2866
2867                 //
2868                 // The volume has been taken off line so fail the access
2869                 //
2870
2871                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2872                               AFS_TRACE_LEVEL_ERROR,
2873                               "AFSParseName (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
2874                               Irp,
2875                               pVolumeCB->ObjectInformation.FileId.Cell,
2876                               pVolumeCB->ObjectInformation.FileId.Volume);
2877
2878                 AFSReleaseResource( pVolumeCB->VolumeLock);
2879
2880                 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
2881             }
2882
2883             if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
2884             {
2885
2886                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2887                               AFS_TRACE_LEVEL_VERBOSE,
2888                               "AFSParseName (%p) Verifying root of volume %08lX:%08lX\n",
2889                               Irp,
2890                               pVolumeCB->ObjectInformation.FileId.Cell,
2891                               pVolumeCB->ObjectInformation.FileId.Volume);
2892
2893                 ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
2894                                             pVolumeCB);
2895
2896                 if( !NT_SUCCESS( ntStatus))
2897                 {
2898
2899                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2900                                   AFS_TRACE_LEVEL_ERROR,
2901                                   "AFSParseName (%p) Failed verification of root Status %08lX\n",
2902                                   Irp,
2903                                   ntStatus);
2904
2905                     AFSReleaseResource( pVolumeCB->VolumeLock);
2906
2907                     try_return( ntStatus);
2908                 }
2909             }
2910
2911             AFSReleaseResource( pVolumeCB->VolumeLock);
2912
2913             if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
2914             {
2915
2916                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2917                               AFS_TRACE_LEVEL_VERBOSE,
2918                               "AFSParseName (%p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2919                               Irp,
2920                               &pDirEntry->NameInformation.FileName,
2921                               pDirEntry->ObjectInformation->FileId.Cell,
2922                               pDirEntry->ObjectInformation->FileId.Volume,
2923                               pDirEntry->ObjectInformation->FileId.Vnode,
2924                               pDirEntry->ObjectInformation->FileId.Unique);
2925
2926                 //
2927                 // Directory TreeLock should be exclusively held
2928                 //
2929
2930                 AFSAcquireExcl( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
2931                                 TRUE);
2932
2933                 ntStatus = AFSVerifyEntry( AuthGroup,
2934                                            pDirEntry);
2935
2936                 AFSReleaseResource( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
2937
2938                 if( !NT_SUCCESS( ntStatus))
2939                 {
2940
2941                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2942                                   AFS_TRACE_LEVEL_VERBOSE,
2943                                   "AFSParseName (%p) Failed verification of parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2944                                   Irp,
2945                                   &pDirEntry->NameInformation.FileName,
2946                                   pDirEntry->ObjectInformation->FileId.Cell,
2947                                   pDirEntry->ObjectInformation->FileId.Volume,
2948                                   pDirEntry->ObjectInformation->FileId.Vnode,
2949                                   pDirEntry->ObjectInformation->FileId.Unique,
2950                                   ntStatus);
2951
2952                     try_return( ntStatus);
2953                 }
2954             }
2955
2956             //
2957             // Create our full path name buffer
2958             //
2959
2960             uniFullName.MaximumLength = pRelatedCcb->FullFileName.Length +
2961                                                     sizeof( WCHAR) +
2962                                                     pIrpSp->FileObject->FileName.Length +
2963                                                     sizeof( WCHAR);
2964
2965             uniFullName.Length = 0;
2966
2967             uniFullName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2968                                                                     uniFullName.MaximumLength,
2969                                                                     AFS_NAME_BUFFER_THREE_TAG);
2970
2971             if( uniFullName.Buffer == NULL)
2972             {
2973
2974                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2975                               AFS_TRACE_LEVEL_ERROR,
2976                               "AFSParseName (%p) Failed to allocate full name buffer\n",
2977                               Irp);
2978
2979                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2980             }
2981
2982             RtlZeroMemory( uniFullName.Buffer,
2983                            uniFullName.MaximumLength);
2984
2985             RtlCopyMemory( uniFullName.Buffer,
2986                            pRelatedCcb->FullFileName.Buffer,
2987                            pRelatedCcb->FullFileName.Length);
2988
2989             uniFullName.Length = pRelatedCcb->FullFileName.Length;
2990
2991             usComponentIndex = (USHORT)(uniFullName.Length/sizeof( WCHAR));
2992
2993             usComponentLength = pIrpSp->FileObject->FileName.Length;
2994
2995             if( uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
2996                 pIrpSp->FileObject->FileName.Length > 0 &&
2997                 pIrpSp->FileObject->FileName.Buffer[ 0] != L'\\' &&
2998                 pIrpSp->FileObject->FileName.Buffer[ 0] != L':')
2999             {
3000
3001                 uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR))] = L'\\';
3002
3003                 uniFullName.Length += sizeof( WCHAR);
3004
3005                 usComponentLength += sizeof( WCHAR);
3006             }
3007
3008             if( pIrpSp->FileObject->FileName.Length > 0)
3009             {
3010
3011                 RtlCopyMemory( &uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)],
3012                                pIrpSp->FileObject->FileName.Buffer,
3013                                pIrpSp->FileObject->FileName.Length);
3014
3015                 uniFullName.Length += pIrpSp->FileObject->FileName.Length;
3016             }
3017
3018             *RootFileName = uniFullName;
3019
3020             //
3021             // We populate up to the current parent
3022             //
3023
3024             if( pRelatedNameArray == NULL)
3025             {
3026
3027                 //
3028                 // Init and populate our name array
3029                 //
3030
3031                 pNameArray = AFSInitNameArray( NULL,
3032                                                0);
3033
3034                 if( pNameArray == NULL)
3035                 {
3036
3037                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3038                                   AFS_TRACE_LEVEL_VERBOSE,
3039                                   "AFSParseName (%p) Failed to initialize name array\n",
3040                                   Irp);
3041
3042                     AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3043
3044                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3045                 }
3046
3047                 ntStatus = AFSPopulateNameArray( pNameArray,
3048                                                  NULL,
3049                                                  pRelatedCcb->DirectoryCB);
3050             }
3051             else
3052             {
3053
3054                 //
3055                 // Init and populate our name array
3056                 //
3057
3058                 pNameArray = AFSInitNameArray( NULL,
3059                                                pRelatedNameArray->MaxElementCount);
3060
3061                 if( pNameArray == NULL)
3062                 {
3063
3064                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3065                                   AFS_TRACE_LEVEL_VERBOSE,
3066                                   "AFSParseName (%p) Failed to initialize name array\n",
3067                                   Irp);
3068
3069                     AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3070
3071                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3072                 }
3073
3074                 ntStatus = AFSPopulateNameArrayFromRelatedArray( pNameArray,
3075                                                                  pRelatedNameArray,
3076                                                                  pRelatedCcb->DirectoryCB);
3077             }
3078
3079             if( !NT_SUCCESS( ntStatus))
3080             {
3081
3082                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3083                               AFS_TRACE_LEVEL_VERBOSE,
3084                               "AFSParseName (%p) Failed to populate name array\n",
3085                               Irp);
3086
3087                 AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3088
3089                 try_return( ntStatus);
3090             }
3091
3092             ParsedFileName->Length = usComponentLength;
3093             ParsedFileName->MaximumLength = uniFullName.MaximumLength;
3094
3095             ParsedFileName->Buffer = &uniFullName.Buffer[ usComponentIndex];
3096
3097             //
3098             // Indicate to caller that RootFileName must be freed
3099             //
3100
3101             SetFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
3102
3103             *NameArray = pNameArray;
3104
3105             //
3106             // Increment our volume reference count
3107             //
3108
3109             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
3110
3111             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
3112                           AFS_TRACE_LEVEL_VERBOSE,
3113                           "AFSParseName Increment count on volume %p Cnt %d\n",
3114                           pVolumeCB,
3115                           lCount);
3116
3117             *VolumeCB = pVolumeCB;
3118
3119             *ParentDirectoryCB = pDirEntry;
3120
3121             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3122                           AFS_TRACE_LEVEL_VERBOSE_2,
3123                           "AFSParseName (%p) Returning full name %wZ\n",
3124                           Irp,
3125                           &uniFullName);
3126
3127             try_return( ntStatus);
3128         }
3129
3130         //
3131         // No wild cards in the name
3132         //
3133
3134         uniFullName = pIrpSp->FileObject->FileName;
3135
3136         if( FsRtlDoesNameContainWildCards( &uniFullName) ||
3137             uniFullName.Length < AFSServerName.Length)
3138         {
3139
3140             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3141                           AFS_TRACE_LEVEL_ERROR,
3142                           "AFSParseName (%p) Name %wZ contains wild cards or too short\n",
3143                           Irp,
3144                           &uniFullName);
3145
3146             try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3147         }
3148
3149         //
3150         // The name is a fully qualified name. Parse out the server/share names and
3151         // point to the root qualified name
3152         // First thing is to locate the server name
3153         //
3154
3155         FsRtlDissectName( uniFullName,
3156                           &uniComponentName,
3157                           &uniRemainingPath);
3158
3159         uniFullName = uniRemainingPath;
3160
3161         //
3162         // This component is the server name we are serving
3163         //
3164
3165         if( RtlCompareUnicodeString( &uniComponentName,
3166                                      &AFSServerName,
3167                                      TRUE) != 0)
3168         {
3169
3170             //
3171             // Drive letter based name?
3172             //
3173
3174             uniFullName = pIrpSp->FileObject->FileName;
3175
3176             while( usIndex < uniFullName.Length/sizeof( WCHAR))
3177             {
3178
3179                 if( uniFullName.Buffer[ usIndex] == L':')
3180                 {
3181
3182                     uniFullName.Buffer = &uniFullName.Buffer[ usIndex + 2];
3183
3184                     uniFullName.Length -= (usIndex + 2) * sizeof( WCHAR);
3185
3186                     usDriveIndex = usIndex - 1;
3187
3188                     break;
3189                 }
3190
3191                 usIndex++;
3192             }
3193
3194             //
3195             // Do we have the right server name now?
3196             //
3197
3198             FsRtlDissectName( uniFullName,
3199                               &uniComponentName,
3200                               &uniRemainingPath);
3201
3202             uniFullName = uniRemainingPath;
3203
3204             //
3205             // This component is the server name we are serving
3206             //
3207
3208             if( RtlCompareUnicodeString( &uniComponentName,
3209                                          &AFSServerName,
3210                                          TRUE) != 0)
3211             {
3212
3213                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3214                               AFS_TRACE_LEVEL_ERROR,
3215                               "AFSParseName (%p) Name %wZ does not have server name\n",
3216                               Irp,
3217                               &pIrpSp->FileObject->FileName);
3218
3219                 try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
3220             }
3221
3222             //
3223             // Validate this drive letter is actively mapped
3224             //
3225
3226             if( usDriveIndex > 0 &&
3227                 !AFSIsDriveMapped( pIrpSp->FileObject->FileName.Buffer[ usDriveIndex]))
3228             {
3229
3230                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3231                               AFS_TRACE_LEVEL_ERROR,
3232                               "AFSParseName (%p) Name %wZ contains invalid drive mapping\n",
3233                               Irp,
3234                               &pIrpSp->FileObject->FileName);
3235
3236                 try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
3237             }
3238         }
3239
3240         if( FsRtlDoesNameContainWildCards( &uniFullName))
3241         {
3242
3243             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3244                           AFS_TRACE_LEVEL_ERROR,
3245                           "AFSParseName (%p) Component %wZ contains wild cards\n",
3246                           Irp,
3247                           &uniFullName);
3248
3249             try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3250         }
3251
3252         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3253                       AFS_TRACE_LEVEL_VERBOSE_2,
3254                       "AFSParseName (%p) Processing full name %wZ\n",
3255                       Irp,
3256                       &uniFullName);
3257
3258         if( uniFullName.Length > 0 &&
3259             uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] == L'\\')
3260         {
3261
3262             uniFullName.Length -= sizeof( WCHAR);
3263         }
3264
3265         //
3266         // Be sure we are online and ready to go
3267         //
3268
3269         AFSAcquireShared( AFSGlobalRoot->VolumeLock,
3270                           TRUE);
3271
3272         if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
3273             BooleanFlagOn( AFSGlobalRoot->Flags, AFS_VOLUME_FLAGS_OFFLINE))
3274         {
3275
3276             //
3277             // The volume has been taken off line so fail the access
3278             //
3279
3280             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3281                           AFS_TRACE_LEVEL_ERROR,
3282                           "AFSParseName (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
3283                           Irp,
3284                           AFSGlobalRoot->ObjectInformation.FileId.Cell,
3285                           AFSGlobalRoot->ObjectInformation.FileId.Volume);
3286
3287             AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3288
3289             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
3290         }
3291
3292         if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
3293         {
3294
3295             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3296                           AFS_TRACE_LEVEL_VERBOSE,
3297                           "AFSParseName (%p) Verifying root of volume %08lX:%08lX\n",
3298                           Irp,
3299                           AFSGlobalRoot->ObjectInformation.FileId.Cell,
3300                           AFSGlobalRoot->ObjectInformation.FileId.Volume);
3301
3302             ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
3303                                         AFSGlobalRoot);
3304
3305             if( !NT_SUCCESS( ntStatus))
3306             {
3307
3308                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3309                               AFS_TRACE_LEVEL_ERROR,
3310                               "AFSParseName (%p) Failed verification of root Status %08lX\n",
3311                               Irp,
3312                               ntStatus);
3313
3314                 AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3315
3316                 try_return( ntStatus);
3317             }
3318         }
3319
3320         AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3321
3322         if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
3323         {
3324
3325             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3326                           AFS_TRACE_LEVEL_VERBOSE,
3327                           "AFSParseName (%p) Enumerating global root of volume %08lX:%08lX\n",
3328                           Irp,
3329                           AFSGlobalRoot->ObjectInformation.FileId.Cell,
3330                           AFSGlobalRoot->ObjectInformation.FileId.Volume);
3331
3332             ntStatus = AFSEnumerateGlobalRoot( AuthGroup);
3333
3334             if( !NT_SUCCESS( ntStatus))
3335             {
3336
3337                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3338                               AFS_TRACE_LEVEL_ERROR,
3339                               "AFSParseName (%p) Failed enumeraiton of root Status %08lX\n",
3340                               Irp,
3341                               ntStatus);
3342
3343                 try_return( ntStatus);
3344             }
3345         }
3346
3347         //
3348         // Check for the \\Server access and return it as though it were \\Server\Globalroot
3349         //
3350
3351         if( uniRemainingPath.Buffer == NULL ||
3352             ( uniRemainingPath.Length == sizeof( WCHAR) &&
3353               uniRemainingPath.Buffer[ 0] == L'\\'))
3354         {
3355
3356             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3357                           AFS_TRACE_LEVEL_VERBOSE_2,
3358                           "AFSParseName (%p) Returning global root access\n",
3359                           Irp);
3360
3361             lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3362
3363             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3364                           AFS_TRACE_LEVEL_VERBOSE,
3365                           "AFSParseName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
3366                           &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3367                           AFSGlobalRoot->DirectoryCB,
3368                           NULL,
3369                           lCount);
3370
3371             *VolumeCB = NULL;
3372
3373             FileName->Length = 0;
3374             FileName->MaximumLength = 0;
3375             FileName->Buffer = NULL;
3376
3377             try_return( ntStatus = STATUS_SUCCESS);
3378         }
3379
3380         *RootFileName = uniFullName;
3381
3382         //
3383         // Include the starting \ in the root name
3384         //
3385
3386         if( RootFileName->Buffer[ 0] != L'\\')
3387         {
3388             RootFileName->Buffer--;
3389             RootFileName->Length += sizeof( WCHAR);
3390             RootFileName->MaximumLength += sizeof( WCHAR);
3391         }
3392
3393         //
3394         // Get the 'share' name
3395         //
3396
3397         FsRtlDissectName( uniFullName,
3398                           &uniComponentName,
3399                           &uniRemainingPath);
3400
3401         if( FsRtlDoesNameContainWildCards( &uniFullName))
3402         {
3403
3404             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3405                           AFS_TRACE_LEVEL_ERROR,
3406                           "AFSParseName (%p) Component %wZ contains wild cards\n",
3407                           Irp,
3408                           &uniComponentName);
3409
3410             try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3411         }
3412
3413         //
3414         // If this is the ALL access then perform some additional processing
3415         //
3416
3417         if( uniComponentName.Length == 0 ||
3418             RtlCompareUnicodeString( &uniComponentName,
3419                                      &AFSGlobalRootName,
3420                                      TRUE) == 0)
3421         {
3422
3423             bIsAllShare = TRUE;
3424
3425             //
3426             // If there is nothing else then get out
3427             //
3428
3429             if( uniRemainingPath.Buffer == NULL ||
3430                 uniRemainingPath.Length == 0 ||
3431                 ( uniRemainingPath.Length == sizeof( WCHAR) &&
3432                   uniRemainingPath.Buffer[ 0] == L'\\'))
3433             {
3434
3435                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3436                               AFS_TRACE_LEVEL_VERBOSE_2,
3437                               "AFSParseName (%p) Returning global root access\n",
3438                               Irp);
3439
3440                 lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3441
3442                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3443                               AFS_TRACE_LEVEL_VERBOSE,
3444                               "AFSParseName Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
3445                               &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3446                               AFSGlobalRoot->DirectoryCB,
3447                               NULL,
3448                               lCount);
3449
3450                 *VolumeCB = NULL;
3451
3452                 FileName->Length = 0;
3453                 FileName->MaximumLength = 0;
3454                 FileName->Buffer = NULL;
3455
3456                 try_return( ntStatus = STATUS_SUCCESS);
3457             }
3458
3459             //
3460             // Process the name again to strip off the ALL portion
3461             //
3462
3463             uniFullName = uniRemainingPath;
3464
3465             FsRtlDissectName( uniFullName,
3466                               &uniComponentName,
3467                               &uniRemainingPath);
3468
3469             //
3470             // Check for the PIOCtl name
3471             //
3472
3473             if( RtlCompareUnicodeString( &uniComponentName,
3474                                          &AFSPIOCtlName,
3475                                          TRUE) == 0)
3476             {
3477
3478                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3479                               AFS_TRACE_LEVEL_VERBOSE_2,
3480                               "AFSParseName (%p) Returning root PIOCtl access\n",
3481                               Irp);
3482
3483                 lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3484
3485                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3486                               AFS_TRACE_LEVEL_VERBOSE,
3487                               "AFSParseName Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
3488                               &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3489                               AFSGlobalRoot->DirectoryCB,
3490                               NULL,
3491                               lCount);
3492
3493                 ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3494
3495                 *VolumeCB = NULL;
3496
3497                 *FileName = AFSPIOCtlName;
3498
3499                 try_return( ntStatus = STATUS_SUCCESS);
3500             }
3501         }
3502         else if( (pDirEntry = AFSGetSpecialShareNameEntry( &uniComponentName,
3503                                                            &uniRemainingPath)) != NULL)
3504         {
3505
3506             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3507                           AFS_TRACE_LEVEL_VERBOSE_2,
3508                           "AFSParseName (%p) Returning root share name %wZ access\n",
3509                           Irp,
3510                           &uniComponentName);
3511
3512             //
3513             // Add in the full share name to pass back
3514             //
3515
3516             if( uniRemainingPath.Buffer != NULL)
3517             {
3518
3519                 //
3520                 // This routine strips off the leading slash so add it back in
3521                 //
3522
3523                 uniRemainingPath.Buffer--;
3524                 uniRemainingPath.Length += sizeof( WCHAR);
3525                 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3526
3527                 //
3528                 // And the cell name
3529                 //
3530
3531                 uniRemainingPath.Buffer -= (uniComponentName.Length/sizeof( WCHAR));
3532                 uniRemainingPath.Length += uniComponentName.Length;
3533                 uniRemainingPath.MaximumLength += uniComponentName.Length;
3534
3535                 uniComponentName = uniRemainingPath;
3536             }
3537
3538             *VolumeCB = NULL;
3539
3540             *FileName = uniComponentName;
3541
3542             ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3543
3544             *ParentDirectoryCB = pDirEntry;
3545
3546             try_return( ntStatus = STATUS_SUCCESS);
3547         }
3548
3549         //
3550         // Determine the 'share' we are accessing
3551         //
3552
3553         ulCRC = AFSGenerateCRC( &uniComponentName,
3554                                 FALSE);
3555
3556         AFSAcquireShared( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
3557                           TRUE);
3558
3559         bReleaseTreeLock = TRUE;
3560
3561         AFSLocateCaseSensitiveDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
3562                                         ulCRC,
3563                                         &pDirEntry);
3564
3565         if( pDirEntry == NULL)
3566         {
3567
3568             ulCRC = AFSGenerateCRC( &uniComponentName,
3569                                     TRUE);
3570
3571             AFSLocateCaseInsensitiveDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
3572                                               ulCRC,
3573                                               &pDirEntry);
3574
3575             if( pDirEntry == NULL)
3576             {
3577
3578                 //
3579                 // OK, if this component is a valid short name then try
3580                 // a lookup in the short name tree
3581                 //
3582
3583                 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3584                     RtlIsNameLegalDOS8Dot3( &uniComponentName,
3585                                             NULL,
3586                                             NULL))
3587                 {
3588
3589                     AFSLocateShortNameDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.ShortNameTree,
3590                                                 ulCRC,
3591                                                 &pDirEntry);
3592                 }
3593
3594                 if( pDirEntry == NULL)
3595                 {
3596
3597                     //
3598                     // Check with the service whether it is a valid cell name
3599                     //
3600
3601                     AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
3602
3603                     bReleaseTreeLock = FALSE;
3604
3605                     ntStatus = AFSCheckCellName( AuthGroup,
3606                                                  &uniComponentName,
3607                                                  &pDirEntry);
3608
3609                     if( !NT_SUCCESS( ntStatus))
3610                     {
3611
3612                         if ( bIsAllShare &&
3613                              uniRemainingPath.Length == 0 &&
3614                              ntStatus == STATUS_OBJECT_PATH_NOT_FOUND)
3615                         {
3616
3617                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3618                                           AFS_TRACE_LEVEL_VERBOSE,
3619                                           "AFSParseName (%08lX) AFSCheckCellName %wZ returned path not found; ntStatus %08X\n",
3620                                           Irp,
3621                                           &uniComponentName,
3622                                           STATUS_OBJECT_NAME_NOT_FOUND);
3623
3624                             ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
3625                         }
3626
3627                         try_return( ntStatus);
3628                     }
3629                 }
3630             }
3631         }
3632
3633         if( bReleaseTreeLock)
3634         {
3635             AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
3636         }
3637
3638
3639         //
3640         // Be sure we are starting from the correct volume
3641         //
3642
3643         if( pDirEntry->ObjectInformation->VolumeCB != AFSGlobalRoot)
3644         {
3645
3646             //
3647             // We dropped the global root in the CheckCellName routine which is the
3648             // only way we can be here
3649             //
3650
3651             pVolumeCB = pDirEntry->ObjectInformation->VolumeCB;
3652
3653             //
3654             // Init our name array
3655             //
3656
3657             pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
3658                                            0);
3659
3660             if( pNameArray == NULL)
3661             {
3662
3663                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3664                               AFS_TRACE_LEVEL_VERBOSE,
3665                               "AFSParseName (%p) Failed to initialize name array\n",
3666                               Irp);
3667
3668                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3669             }
3670
3671             ntStatus = AFSInsertNextElement( pNameArray,
3672                                              pVolumeCB->DirectoryCB);
3673
3674             if ( ntStatus)
3675             {
3676
3677                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3678                               AFS_TRACE_LEVEL_VERBOSE,
3679                               "AFSParseName (%p) Failed to insert name array element\n",
3680                               Irp);
3681
3682                 try_return( ntStatus);
3683             }
3684
3685             //
3686             // In this case don't add back in the 'share' name since that is where we are
3687             // starting. Just put the leading slash back in
3688             //
3689
3690             if( uniRemainingPath.Buffer != NULL)
3691             {
3692
3693                 uniRemainingPath.Buffer--;
3694                 uniRemainingPath.Length += sizeof( WCHAR);
3695                 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3696
3697                 if( uniRemainingPath.Length > sizeof( WCHAR))
3698                 {
3699
3700                     ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3701                 }
3702
3703                 //
3704                 // Pass back the parent being the root of the volume
3705                 //
3706
3707                 *ParentDirectoryCB = pVolumeCB->DirectoryCB;
3708             }
3709             else
3710             {
3711
3712                 //
3713                 // Pass back a root slash
3714                 //
3715
3716                 uniRemainingPath = uniComponentName;
3717
3718                 uniRemainingPath.Buffer--;
3719                 uniRemainingPath.Length = sizeof( WCHAR);
3720                 uniRemainingPath.MaximumLength = sizeof( WCHAR);
3721
3722                 //
3723                 // This is a root open so pass back no parent
3724                 //
3725             }
3726         }
3727         else
3728         {
3729
3730             pVolumeCB = AFSGlobalRoot;
3731
3732             //
3733             // Init our name array
3734             //
3735
3736             pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
3737                                            0);
3738             if( pNameArray == NULL)
3739             {
3740
3741                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3742                               AFS_TRACE_LEVEL_VERBOSE,
3743                               "AFSParseName (%p) Failed to initialize name array\n",
3744                               Irp);
3745
3746                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3747             }
3748
3749             //
3750             // Add back in the 'share' portion of the name since we will parse it out on return
3751             //
3752
3753             if( uniRemainingPath.Buffer != NULL)
3754             {
3755
3756                 //
3757                 // This routine strips off the leading slash so add it back in
3758                 //
3759
3760                 uniRemainingPath.Buffer--;
3761                 uniRemainingPath.Length += sizeof( WCHAR);
3762                 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3763
3764                 if( uniRemainingPath.Length > sizeof( WCHAR))
3765                 {
3766
3767                     ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3768                 }
3769
3770                 //
3771                 // And the cell name
3772                 //
3773
3774                 uniRemainingPath.Buffer -= (uniComponentName.Length/sizeof( WCHAR));
3775                 uniRemainingPath.Length += uniComponentName.Length;
3776                 uniRemainingPath.MaximumLength += uniComponentName.Length;
3777             }
3778             else
3779             {
3780
3781                 uniRemainingPath = uniComponentName;
3782             }
3783
3784             //
3785             // And the leading slash again ...
3786             //
3787
3788             uniRemainingPath.Buffer--;
3789             uniRemainingPath.Length += sizeof( WCHAR);
3790             uniRemainingPath.MaximumLength += sizeof( WCHAR);
3791
3792             //
3793             // Pass back the parent being the volume root
3794             //
3795
3796             *ParentDirectoryCB = pVolumeCB->DirectoryCB;
3797         }
3798
3799         //
3800         // Return the remaining portion as the file name
3801         //
3802
3803         *FileName = uniRemainingPath;
3804
3805         *ParsedFileName = uniRemainingPath;
3806
3807         *NameArray = pNameArray;
3808
3809         *VolumeCB = pVolumeCB;
3810
3811         //
3812         // Increment our reference on the volume
3813         //
3814
3815         lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
3816
3817         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
3818                       AFS_TRACE_LEVEL_VERBOSE,
3819                       "AFSParseName Increment2 count on global volume %p Cnt %d\n",
3820                       pVolumeCB,
3821                       lCount);
3822
3823 try_exit:
3824
3825         if( NT_SUCCESS( ntStatus))
3826         {
3827
3828             if( *ParentDirectoryCB != NULL)
3829             {
3830
3831                 lCount = InterlockedIncrement( &(*ParentDirectoryCB)->DirOpenReferenceCount);
3832
3833                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3834                               AFS_TRACE_LEVEL_VERBOSE,
3835                               "AFSParseName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
3836                               &(*ParentDirectoryCB)->NameInformation.FileName,
3837                               (*ParentDirectoryCB),
3838                               NULL,
3839                               lCount);
3840             }
3841         }
3842
3843         if( *VolumeCB != NULL)
3844         {
3845             ASSERT( (*VolumeCB)->VolumeReferenceCount > 1);
3846         }
3847
3848         if( ntStatus != STATUS_SUCCESS)
3849         {
3850
3851             if( pNameArray != NULL)
3852             {
3853
3854                 AFSFreeNameArray( pNameArray);
3855             }
3856         }
3857     }
3858
3859     return ntStatus;
3860 }
3861
3862 NTSTATUS
3863 AFSCheckCellName( IN GUID *AuthGroup,
3864                   IN UNICODE_STRING *CellName,
3865                   OUT AFSDirectoryCB **ShareDirEntry)
3866 {
3867
3868     NTSTATUS ntStatus = STATUS_SUCCESS;
3869     UNICODE_STRING uniName;
3870     AFSDirEnumEntry *pDirEnumEntry = NULL;
3871     AFSDirHdr *pDirHdr = &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr;
3872     AFSDirectoryCB *pDirNode = NULL;
3873     UNICODE_STRING uniDirName, uniTargetName;
3874     AFSVolumeCB *pVolumeCB = NULL;
3875     LONG lCount;
3876
3877     __Enter
3878     {
3879
3880         //
3881         // Look for some default names we will not handle
3882         //
3883
3884         RtlInitUnicodeString( &uniName,
3885                               L"IPC$");
3886
3887         if( RtlCompareUnicodeString( &uniName,
3888                                      CellName,
3889                                      TRUE) == 0)
3890         {
3891
3892             try_return( ntStatus = STATUS_NO_SUCH_FILE);
3893         }
3894
3895         RtlInitUnicodeString( &uniName,
3896                               L"wkssvc");
3897
3898         if( RtlCompareUnicodeString( &uniName,
3899                                      CellName,
3900                                      TRUE) == 0)
3901         {
3902
3903             try_return( ntStatus = STATUS_NO_SUCH_FILE);
3904         }
3905
3906         RtlInitUnicodeString( &uniName,
3907                               L"srvsvc");
3908
3909         if( RtlCompareUnicodeString( &uniName,
3910                                      CellName,
3911                                      TRUE) == 0)
3912         {
3913
3914             try_return( ntStatus = STATUS_NO_SUCH_FILE);
3915         }
3916
3917         RtlInitUnicodeString( &uniName,
3918                               L"PIPE");
3919
3920         if( RtlCompareUnicodeString( &uniName,
3921                                      CellName,
3922                                      TRUE) == 0)
3923         {
3924
3925             try_return( ntStatus = STATUS_NO_SUCH_FILE);
3926         }
3927
3928         //
3929         // OK, ask the CM about this component name
3930         //
3931
3932         ntStatus = AFSEvaluateTargetByName( AuthGroup,
3933                                             &AFSGlobalRoot->ObjectInformation,
3934                                             CellName,
3935                                             &pDirEnumEntry);
3936
3937         if( !NT_SUCCESS( ntStatus))
3938         {
3939
3940             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3941                           AFS_TRACE_LEVEL_WARNING,
3942                           "AFSCheckCellName entry %wZ does not exist parent FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3943                           CellName,
3944                           AFSGlobalRoot->ObjectInformation.FileId.Cell,
3945                           AFSGlobalRoot->ObjectInformation.FileId.Volume,
3946                           AFSGlobalRoot->ObjectInformation.FileId.Vnode,
3947                           AFSGlobalRoot->ObjectInformation.FileId.Unique,
3948                           ntStatus);
3949
3950             try_return( ntStatus);
3951         }
3952
3953         //
3954         // OK, we have a dir enum entry back so add it to the root node
3955         //
3956
3957         uniDirName = *CellName;
3958
3959         uniTargetName.Length = (USHORT)pDirEnumEntry->TargetNameLength;
3960         uniTargetName.MaximumLength = uniTargetName.Length;
3961         uniTargetName.Buffer = (WCHAR *)((char *)pDirEnumEntry + pDirEnumEntry->TargetNameOffset);
3962
3963         //
3964         // Is this entry a root volume entry?
3965         //
3966
3967         if( pDirEnumEntry->FileId.Cell != AFSGlobalRoot->ObjectInformation.FileId.Cell ||
3968             pDirEnumEntry->FileId.Volume != AFSGlobalRoot->ObjectInformation.FileId.Volume)
3969         {
3970
3971             //
3972             // Build the root volume entry
3973             //
3974
3975             ntStatus = AFSBuildRootVolume( AuthGroup,
3976                                            &pDirEnumEntry->FileId,
3977                                            &pVolumeCB);
3978
3979             if( !NT_SUCCESS( ntStatus))
3980             {
3981                 try_return( ntStatus);
3982             }
3983
3984             *ShareDirEntry = pVolumeCB->DirectoryCB;
3985
3986             lCount = InterlockedIncrement( &pVolumeCB->DirectoryCB->DirOpenReferenceCount);
3987
3988             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3989                           AFS_TRACE_LEVEL_VERBOSE,
3990                           "AFSCheckCellName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
3991                           &pVolumeCB->DirectoryCB->NameInformation.FileName,
3992                           pVolumeCB->DirectoryCB,
3993                           NULL,
3994                           lCount);
3995
3996             lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
3997
3998             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
3999                           AFS_TRACE_LEVEL_VERBOSE,
4000                           "AFSCheckCellName Increment count on volume %p Cnt %d\n",
4001                           pVolumeCB,
4002                           lCount);
4003         }
4004         else
4005         {
4006
4007             lCount = InterlockedIncrement( &pDirHdr->ContentIndex);
4008
4009             pDirNode = AFSInitDirEntry( &AFSGlobalRoot->ObjectInformation,
4010                                         &uniDirName,
4011                                         &uniTargetName,
4012                                         pDirEnumEntry,
4013                                         (ULONG)lCount);
4014
4015             if( pDirNode == NULL)
4016             {
4017
4018                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4019             }
4020
4021             //
4022             // Init the short name if we have one
4023             //
4024
4025             if( pDirEnumEntry->ShortNameLength > 0)
4026             {
4027
4028                 pDirNode->NameInformation.ShortNameLength = pDirEnumEntry->ShortNameLength;
4029
4030                 RtlCopyMemory( pDirNode->NameInformation.ShortName,
4031                                pDirEnumEntry->ShortName,
4032                                pDirNode->NameInformation.ShortNameLength);
4033             }
4034
4035             AFSAcquireExcl( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
4036                             TRUE);
4037
4038             //
4039             // Insert the node into the name tree
4040             //
4041
4042             ASSERT( ExIsResourceAcquiredExclusiveLite( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock));
4043
4044             if( pDirHdr->CaseSensitiveTreeHead == NULL)
4045             {
4046
4047                 pDirHdr->CaseSensitiveTreeHead = pDirNode;
4048             }
4049             else
4050             {
4051
4052                 if( !NT_SUCCESS( AFSInsertCaseSensitiveDirEntry( pDirHdr->CaseSensitiveTreeHead,
4053                                                                  pDirNode)))
4054                 {
4055
4056                     AFSDeleteDirEntry( &AFSGlobalRoot->ObjectInformation,
4057                                        pDirNode);
4058
4059                     AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
4060
4061                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4062                 }
4063             }
4064
4065             ClearFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
4066
4067             if( pDirHdr->CaseInsensitiveTreeHead == NULL)
4068             {
4069
4070                 pDirHdr->CaseInsensitiveTreeHead = pDirNode;
4071
4072                 SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
4073             }
4074             else
4075             {
4076
4077                 AFSInsertCaseInsensitiveDirEntry( pDirHdr->CaseInsensitiveTreeHead,
4078                                                   pDirNode);
4079             }
4080
4081             if( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead == NULL)
4082             {
4083
4084                 AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead = pDirNode;
4085             }
4086             else
4087             {
4088
4089                 AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail->ListEntry.fLink = pDirNode;
4090
4091                 pDirNode->ListEntry.bLink = AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail;
4092             }
4093
4094             AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail = pDirNode;
4095
4096             SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
4097
4098             lCount = InterlockedIncrement( &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeCount);
4099
4100             AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
4101                           AFS_TRACE_LEVEL_VERBOSE,
4102                           "AFSCheckCellName Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
4103                           &pDirNode->NameInformation.FileName,
4104                           lCount,
4105                           AFSGlobalRoot->ObjectInformation.FileId.Cell,
4106                           AFSGlobalRoot->ObjectInformation.FileId.Volume,
4107                           AFSGlobalRoot->ObjectInformation.FileId.Vnode,
4108                           AFSGlobalRoot->ObjectInformation.FileId.Unique);
4109
4110             lCount = InterlockedIncrement( &pDirNode->DirOpenReferenceCount);
4111
4112             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4113                           AFS_TRACE_LEVEL_VERBOSE,
4114                           "AFSCheckCellName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
4115                           &pDirNode->NameInformation.FileName,
4116                           pDirNode,
4117                           NULL,
4118                           lCount);
4119
4120             AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
4121
4122             //
4123             // Pass back the dir node
4124             //
4125
4126             *ShareDirEntry = pDirNode;
4127         }
4128
4129 try_exit:
4130
4131         if( pDirEnumEntry != NULL)
4132         {
4133
4134             AFSExFreePoolWithTag( pDirEnumEntry, AFS_GENERIC_MEMORY_31_TAG);
4135         }
4136     }
4137
4138     return ntStatus;
4139 }
4140
4141 NTSTATUS
4142 AFSBuildMountPointTarget( IN GUID *AuthGroup,
4143                           IN AFSDirectoryCB  *DirectoryCB,
4144                           OUT AFSVolumeCB **TargetVolumeCB)
4145 {
4146
4147     NTSTATUS ntStatus = STATUS_SUCCESS;
4148     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4149     AFSDirEnumEntry *pDirEntry = NULL;
4150     ULONGLONG       ullIndex = 0;
4151     AFSVolumeCB *pVolumeCB = NULL;
4152     AFSFileID stTargetFileID;
4153     LONG lCount;
4154     BOOLEAN bReleaseVolumeLock = FALSE;
4155
4156     __Enter
4157     {
4158
4159         //
4160         // Loop on each entry, building the chain until we encounter the final target
4161         //
4162
4163         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4164                       AFS_TRACE_LEVEL_VERBOSE_2,
4165                       "AFSBuildMountPointTarget Building target directory for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4166                       &DirectoryCB->NameInformation.FileName,
4167                       DirectoryCB->ObjectInformation->FileId.Cell,
4168                       DirectoryCB->ObjectInformation->FileId.Volume,
4169                       DirectoryCB->ObjectInformation->FileId.Vnode,
4170                       DirectoryCB->ObjectInformation->FileId.Unique);
4171
4172         //
4173         // Do we need to evaluate the node?
4174         //
4175
4176         //if( DirectoryCB->ObjectInformation->TargetFileId.Vnode == 0 &&
4177         //    DirectoryCB->ObjectInformation->TargetFileId.Unique == 0)
4178         {
4179
4180             //
4181             // Go evaluate the current target to get the target fid
4182             //
4183
4184             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4185                           AFS_TRACE_LEVEL_VERBOSE_2,
4186                           "AFSBuildMountPointTarget Evaluating target %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4187                               &DirectoryCB->NameInformation.FileName,
4188                               DirectoryCB->ObjectInformation->FileId.Cell,
4189                               DirectoryCB->ObjectInformation->FileId.Volume,
4190                               DirectoryCB->ObjectInformation->FileId.Vnode,
4191                               DirectoryCB->ObjectInformation->FileId.Unique);
4192
4193             ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
4194                                               AuthGroup,
4195                                               FALSE,
4196                                               &pDirEntry);
4197
4198             if( !NT_SUCCESS( ntStatus))
4199             {
4200
4201                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4202                               AFS_TRACE_LEVEL_ERROR,
4203                               "AFSBuildMountPointTarget Failed to evaluate target %wZ Status %08lX\n",
4204                               &DirectoryCB->NameInformation.FileName,
4205                               ntStatus);
4206                 try_return( ntStatus);
4207             }
4208
4209             if( pDirEntry->TargetFileId.Vnode == 0 &&
4210                 pDirEntry->TargetFileId.Unique == 0)
4211             {
4212
4213                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4214                               AFS_TRACE_LEVEL_ERROR,
4215                               "AFSBuildMountPointTarget Target %wZ FID %08lX-%08lX-%08lX-%08lX service returned zero FID\n",
4216                               &DirectoryCB->NameInformation.FileName,
4217                               DirectoryCB->ObjectInformation->FileId.Cell,
4218                               DirectoryCB->ObjectInformation->FileId.Volume,
4219                               DirectoryCB->ObjectInformation->FileId.Vnode,
4220                               DirectoryCB->ObjectInformation->FileId.Unique);
4221
4222                 try_return( ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED);
4223             }
4224
4225             AFSAcquireExcl( &DirectoryCB->NonPaged->Lock,
4226                             TRUE);
4227
4228             ntStatus = AFSUpdateTargetName( &DirectoryCB->NameInformation.TargetName,
4229                                             &DirectoryCB->Flags,
4230                                             (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
4231                                             (USHORT)pDirEntry->TargetNameLength);
4232
4233             if( !NT_SUCCESS( ntStatus))
4234             {
4235
4236                 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
4237
4238                 try_return( ntStatus);
4239             }
4240
4241             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
4242
4243             DirectoryCB->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
4244         }
4245
4246         stTargetFileID = DirectoryCB->ObjectInformation->TargetFileId;
4247
4248         //
4249         // Try to locate this FID. First the volume then the
4250         // entry itself
4251         //
4252
4253         ullIndex = AFSCreateHighIndex( &stTargetFileID);
4254
4255         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
4256                       AFS_TRACE_LEVEL_VERBOSE,
4257                       "AFSBuildMountPointTarget Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
4258                       &pDevExt->Specific.RDR.VolumeTreeLock,
4259                       PsGetCurrentThread());
4260
4261         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
4262                           TRUE);
4263
4264         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4265                       AFS_TRACE_LEVEL_VERBOSE_2,
4266                       "AFSBuildMountPointTarget Locating volume for target %I64X\n",
4267                       ullIndex);
4268
4269         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
4270                                        ullIndex,
4271                                        (AFSBTreeEntry **)&pVolumeCB);
4272
4273         //
4274         // We can be processing a request for a target that is on a volume
4275         // we have never seen before.
4276         //
4277
4278         if( pVolumeCB == NULL)
4279         {
4280
4281             //
4282             // Locking is held correctly in init routine
4283             //
4284
4285             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4286
4287             //
4288             // Go init the root of the volume
4289             //
4290
4291             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4292                           AFS_TRACE_LEVEL_VERBOSE_2,
4293                           "AFSBuildMountPointTarget Initializing root for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4294                           &DirectoryCB->NameInformation.FileName,
4295                           DirectoryCB->ObjectInformation->FileId.Cell,
4296                           DirectoryCB->ObjectInformation->FileId.Volume,
4297                           DirectoryCB->ObjectInformation->FileId.Vnode,
4298                           DirectoryCB->ObjectInformation->FileId.Unique);
4299
4300             ntStatus = AFSInitVolume( AuthGroup,
4301                                       &stTargetFileID,
4302                                       &pVolumeCB);
4303
4304             if( !NT_SUCCESS( ntStatus))
4305             {
4306
4307                 try_return( ntStatus);
4308             }
4309
4310             //
4311             // pVolumeCB->VolumeLock held exclusive and
4312             // pVolumeCB->VolumeReferenceCount has been incremented
4313             // pVolumeCB->RootFcb == NULL
4314             //
4315
4316             bReleaseVolumeLock = TRUE;
4317         }
4318         else
4319         {
4320
4321             //
4322             // AFSInitVolume returns with a VolumeReferenceCount
4323             // obtain one to match
4324             //
4325
4326             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
4327
4328             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4329                           AFS_TRACE_LEVEL_VERBOSE,
4330                           "AFSBuildMountPointTarget Increment count on volume %p Cnt %d\n",
4331                           pVolumeCB,
4332                           lCount);
4333
4334             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4335         }
4336
4337         if( pVolumeCB->RootFcb == NULL)
4338         {
4339
4340             if ( bReleaseVolumeLock == FALSE)
4341             {
4342
4343                 AFSAcquireExcl( pVolumeCB->VolumeLock,
4344                                 TRUE);
4345
4346                 bReleaseVolumeLock = TRUE;
4347             }
4348
4349             //
4350             // Initialize the root fcb for this volume
4351             //
4352
4353             ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
4354                                        pVolumeCB);
4355
4356             if( !NT_SUCCESS( ntStatus))
4357             {
4358
4359                 lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
4360
4361                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4362                               AFS_TRACE_LEVEL_VERBOSE,
4363                               "AFSBuildMountPoint Decrement count on volume %p Cnt %d\n",
4364                               pVolumeCB,
4365                               lCount);
4366
4367                 AFSReleaseResource( pVolumeCB->VolumeLock);
4368
4369                 try_return( ntStatus);
4370             }
4371
4372             //
4373             // Drop the lock acquired above
4374             //
4375
4376             AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
4377         }
4378
4379         if ( bReleaseVolumeLock == TRUE)
4380         {
4381
4382             AFSReleaseResource( pVolumeCB->VolumeLock);
4383         }
4384
4385         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4386                       AFS_TRACE_LEVEL_VERBOSE_2,
4387                       "AFSBuildMountPointTarget Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
4388                       &pVolumeCB->DirectoryCB->NameInformation.FileName,
4389                       pVolumeCB->ObjectInformation.FileId.Cell,
4390                       pVolumeCB->ObjectInformation.FileId.Volume,
4391                       pVolumeCB->ObjectInformation.FileId.Vnode,
4392                       pVolumeCB->ObjectInformation.FileId.Unique);
4393
4394         *TargetVolumeCB = pVolumeCB;
4395
4396 try_exit:
4397
4398         if( pDirEntry)
4399         {
4400
4401             AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
4402         }
4403     }
4404
4405     return ntStatus;
4406 }
4407
4408 NTSTATUS
4409 AFSBuildRootVolume( IN GUID *AuthGroup,
4410                     IN AFSFileID *FileId,
4411                     OUT AFSVolumeCB **TargetVolumeCB)
4412 {
4413
4414     NTSTATUS ntStatus = STATUS_SUCCESS;
4415     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4416     ULONGLONG       ullIndex = 0;
4417     AFSVolumeCB *pVolumeCB = NULL;
4418     LONG lCount;
4419     BOOLEAN bReleaseVolumeLock = FALSE;
4420
4421     __Enter
4422     {
4423
4424         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4425                       AFS_TRACE_LEVEL_VERBOSE_2,
4426                       "AFSBuildRootVolume Building target volume for FID %08lX-%08lX-%08lX-%08lX\n",
4427                       FileId->Cell,
4428                       FileId->Volume,
4429                       FileId->Vnode,
4430                       FileId->Unique);
4431
4432         ullIndex = AFSCreateHighIndex( FileId);
4433
4434         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
4435                       AFS_TRACE_LEVEL_VERBOSE,
4436                       "AFSBuildRootVolume Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
4437                       &pDevExt->Specific.RDR.VolumeTreeLock,
4438                       PsGetCurrentThread());
4439
4440         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
4441                           TRUE);
4442
4443         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4444                       AFS_TRACE_LEVEL_VERBOSE_2,
4445                       "AFSBuildRootVolume Locating volume for target %I64X\n",
4446                       ullIndex);
4447
4448         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
4449                                        ullIndex,
4450                                        (AFSBTreeEntry **)&pVolumeCB);
4451
4452         //
4453         // We can be processing a request for a target that is on a volume
4454         // we have never seen before.
4455         //
4456
4457         if( pVolumeCB == NULL)
4458         {
4459
4460             //
4461             // Locking is held correctly in init routine
4462             //
4463
4464             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4465
4466             //
4467             // Go init the root of the volume
4468             //
4469
4470             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4471                          AFS_TRACE_LEVEL_VERBOSE_2,
4472                           "AFSBuildRootVolume Initializing root for FID %08lX-%08lX-%08lX-%08lX\n",
4473                           FileId->Cell,
4474                           FileId->Volume,
4475                           FileId->Vnode,
4476                           FileId->Unique);
4477
4478             ntStatus = AFSInitVolume( AuthGroup,
4479                                       FileId,
4480                                       &pVolumeCB);
4481
4482             if( !NT_SUCCESS( ntStatus))
4483             {
4484
4485                 try_return( ntStatus);
4486             }
4487
4488             //
4489             // pVolumeCB->VolumeLock is held exclusive
4490             // pVolumeCB->VolumeReferenceCount has been incremented
4491             // pVolumeCB->RootFcb == NULL
4492             //
4493
4494             bReleaseVolumeLock = TRUE;
4495         }
4496         else
4497         {
4498
4499             //
4500             // AFSInitVolume returns with a VolumeReferenceCount
4501             // obtain one to match
4502             //
4503
4504             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
4505
4506             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4507                           AFS_TRACE_LEVEL_VERBOSE,
4508                           "AFSBuildRootVolume Increment count on volume %p Cnt %d\n",
4509                           pVolumeCB,
4510                           lCount);
4511
4512             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4513         }
4514
4515
4516         if( pVolumeCB->RootFcb == NULL)
4517         {
4518
4519             if ( bReleaseVolumeLock == FALSE)
4520             {
4521
4522                 AFSAcquireExcl( pVolumeCB->VolumeLock,
4523                                 TRUE);
4524
4525                 bReleaseVolumeLock = TRUE;
4526             }
4527
4528             //
4529             // Initialize the root fcb for this volume
4530             //
4531
4532             ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
4533                                        pVolumeCB);
4534
4535             if( !NT_SUCCESS( ntStatus))
4536             {
4537
4538                 lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
4539
4540                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4541                               AFS_TRACE_LEVEL_VERBOSE,
4542                               "AFSBuildRootVolume Decrement count on volume %p Cnt %d\n",
4543                               pVolumeCB,
4544                               lCount);
4545
4546                 AFSReleaseResource( pVolumeCB->VolumeLock);
4547
4548                 try_return( ntStatus);
4549             }
4550
4551             //
4552             // Drop the lock acquired above
4553             //
4554
4555             AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
4556         }
4557
4558         if ( bReleaseVolumeLock == TRUE)
4559         {
4560
4561             AFSReleaseResource( pVolumeCB->VolumeLock);
4562         }
4563
4564         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4565                       AFS_TRACE_LEVEL_VERBOSE_2,
4566                       "AFSBuildRootVolume Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
4567                       &pVolumeCB->DirectoryCB->NameInformation.FileName,
4568                       pVolumeCB->ObjectInformation.FileId.Cell,
4569                       pVolumeCB->ObjectInformation.FileId.Volume,
4570                       pVolumeCB->ObjectInformation.FileId.Vnode,
4571                       pVolumeCB->ObjectInformation.FileId.Unique);
4572
4573         *TargetVolumeCB = pVolumeCB;
4574
4575 try_exit:
4576
4577         NOTHING;
4578     }
4579
4580     return ntStatus;
4581 }
4582
4583 NTSTATUS
4584 AFSProcessDFSLink( IN AFSDirectoryCB *DirEntry,
4585                    IN PFILE_OBJECT FileObject,
4586                    IN UNICODE_STRING *RemainingPath,
4587                    IN GUID *AuthGroup)
4588 {
4589
4590     NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
4591     UNICODE_STRING uniReparseName;
4592     UNICODE_STRING uniMUPDeviceName;
4593     UNICODE_STRING uniIOMgrDeviceName;
4594     AFSDirEnumEntry *pDirEntry = NULL;
4595
4596     __Enter
4597     {
4598
4599         //
4600         // Build up the name to reparse
4601         //
4602
4603         RtlInitUnicodeString( &uniMUPDeviceName,
4604                               L"\\Device\\MUP");
4605
4606         RtlInitUnicodeString( &uniIOMgrDeviceName,
4607                               L"\\??\\");
4608
4609         uniReparseName.Length = 0;
4610         uniReparseName.Buffer = NULL;
4611
4612         //
4613         // Be sure we have a target name
4614         //
4615
4616         if( DirEntry->NameInformation.TargetName.Length == 0)
4617         {
4618
4619             ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
4620                                               AuthGroup,
4621                                               FALSE,
4622                                               &pDirEntry);
4623
4624             if( !NT_SUCCESS( ntStatus) ||
4625                 pDirEntry->TargetNameLength == 0)
4626             {
4627
4628                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4629                               AFS_TRACE_LEVEL_ERROR,
4630                               "AFSProcessDFSLink EvaluateTargetByID failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4631                               &DirEntry->NameInformation.FileName,
4632                               DirEntry->ObjectInformation->FileId.Cell,
4633                               DirEntry->ObjectInformation->FileId.Volume,
4634                               DirEntry->ObjectInformation->FileId.Vnode,
4635                               DirEntry->ObjectInformation->FileId.Unique,
4636                               ntStatus);
4637
4638                 if( NT_SUCCESS( ntStatus))
4639                 {
4640
4641                     ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
4642                 }
4643
4644                 try_return( ntStatus);
4645             }
4646
4647             //
4648             // Update the target name
4649             //
4650
4651             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
4652                             TRUE);
4653
4654             ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
4655                                             &DirEntry->Flags,
4656                                             (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
4657                                             (USHORT)pDirEntry->TargetNameLength);
4658
4659             if( !NT_SUCCESS( ntStatus))
4660             {
4661
4662                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4663                               AFS_TRACE_LEVEL_ERROR,
4664                               "AFSProcessDFSLink UpdateTargetName failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4665                               &DirEntry->NameInformation.FileName,
4666                               DirEntry->ObjectInformation->FileId.Cell,
4667                               DirEntry->ObjectInformation->FileId.Volume,
4668                               DirEntry->ObjectInformation->FileId.Vnode,
4669                               DirEntry->ObjectInformation->FileId.Unique,
4670                               ntStatus);
4671
4672                 AFSReleaseResource( &DirEntry->NonPaged->Lock);
4673
4674                 try_return( ntStatus);
4675             }
4676
4677             AFSConvertToShared( &DirEntry->NonPaged->Lock);
4678         }
4679         else
4680         {
4681             AFSAcquireShared( &DirEntry->NonPaged->Lock,
4682                               TRUE);
4683         }
4684
4685         uniReparseName.MaximumLength = uniMUPDeviceName.Length +
4686                                                    sizeof( WCHAR) +
4687                                                    DirEntry->NameInformation.TargetName.Length +
4688                                                    sizeof( WCHAR);
4689
4690         if( RemainingPath != NULL &&
4691             RemainingPath->Length > 0)
4692         {
4693
4694             uniReparseName.MaximumLength += RemainingPath->Length;
4695         }
4696
4697         //
4698         // Allocate the reparse buffer
4699         //
4700
4701         uniReparseName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
4702                                                                    uniReparseName.MaximumLength,
4703                                                                    AFS_REPARSE_NAME_TAG);
4704
4705         if( uniReparseName.Buffer == NULL)
4706         {
4707
4708             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4709                           AFS_TRACE_LEVEL_ERROR,
4710                           "AFSProcessDFSLink uniReparseName.Buffer == NULL Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4711                           &DirEntry->NameInformation.FileName,
4712                           DirEntry->ObjectInformation->FileId.Cell,
4713                           DirEntry->ObjectInformation->FileId.Volume,
4714                           DirEntry->ObjectInformation->FileId.Vnode,
4715                           DirEntry->ObjectInformation->FileId.Unique,
4716                           STATUS_INSUFFICIENT_RESOURCES);
4717
4718             AFSReleaseResource( &DirEntry->NonPaged->Lock);
4719
4720             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4721         }
4722
4723         //
4724         // Start building the name
4725         //
4726
4727         if ( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\' &&
4728              DirEntry->NameInformation.TargetName.Buffer[ 1] == L':')
4729         {
4730
4731             RtlCopyMemory( uniReparseName.Buffer,
4732                            uniIOMgrDeviceName.Buffer,
4733                            uniIOMgrDeviceName.Length);
4734
4735             uniReparseName.Length = uniIOMgrDeviceName.Length;
4736         }
4737         else
4738         {
4739
4740             RtlCopyMemory( uniReparseName.Buffer,
4741                            uniMUPDeviceName.Buffer,
4742                            uniMUPDeviceName.Length);
4743
4744             uniReparseName.Length = uniMUPDeviceName.Length;
4745
4746             if( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\')
4747             {
4748
4749                 uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
4750
4751                 uniReparseName.Length += sizeof( WCHAR);
4752             }
4753         }
4754
4755         RtlCopyMemory( &uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)],
4756                        DirEntry->NameInformation.TargetName.Buffer,
4757                        DirEntry->NameInformation.TargetName.Length);
4758
4759         uniReparseName.Length += DirEntry->NameInformation.TargetName.Length;
4760
4761         AFSReleaseResource( &DirEntry->NonPaged->Lock);
4762
4763         if( RemainingPath != NULL &&
4764             RemainingPath->Length > 0)
4765         {
4766
4767             if( uniReparseName.Buffer[ (uniReparseName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
4768                 RemainingPath->Buffer[ 0] != L'\\')
4769             {
4770
4771                 uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
4772
4773                 uniReparseName.Length += sizeof( WCHAR);
4774             }
4775
4776             RtlCopyMemory( &uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)],
4777                            RemainingPath->Buffer,
4778                            RemainingPath->Length);
4779
4780             uniReparseName.Length += RemainingPath->Length;
4781         }
4782
4783         //
4784         // Update the name in the file object
4785         //
4786
4787         if( FileObject->FileName.Buffer != NULL)
4788         {
4789
4790             AFSExFreePoolWithTag( FileObject->FileName.Buffer, 0);
4791         }
4792
4793         FileObject->FileName = uniReparseName;
4794
4795         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4796                       AFS_TRACE_LEVEL_VERBOSE,
4797                       "AFSProcessDFSLink Reparsing access to Fcb %wZ FID %08lX-%08lX-%08lX-%08lX to %wZ\n",
4798                       &DirEntry->NameInformation.FileName,
4799                       DirEntry->ObjectInformation->FileId.Cell,
4800                       DirEntry->ObjectInformation->FileId.Volume,
4801                       DirEntry->ObjectInformation->FileId.Vnode,
4802                       DirEntry->ObjectInformation->FileId.Unique,
4803                       &uniReparseName);
4804
4805         //
4806         // Return status reparse ...
4807         //
4808
4809         ntStatus = STATUS_REPARSE;
4810
4811 try_exit:
4812
4813         if ( pDirEntry)
4814         {
4815
4816             AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
4817         }
4818     }
4819
4820     return ntStatus;
4821 }