src/WINNT/afsrdr/kernel/lib/AFSGeneric.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: AFSGeneric.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSExceptionFilter
  43 //
  44 // Description:
  45 //
  46 //      This function is the exception handler
  47 //
  48 // Return:
  49 //
  50 //      A status is returned for the function
  51 //
  52
  53 ULONG
  54 AFSExceptionFilter( IN ULONG Code,
  55                     IN PEXCEPTION_POINTERS ExceptPtrs)
  56 {
  57
  58     PEXCEPTION_RECORD ExceptRec;
  59     PCONTEXT Context;
  60
  61     __try
  62     {
  63
  64         ExceptRec = ExceptPtrs->ExceptionRecord;
  65
  66         Context = ExceptPtrs->ContextRecord;
  67
  68         AFSDbgLogMsg( 0,
  69                       0,
  70                       "AFSExceptionFilter (Library) - EXR %p CXR %p Code %08lX Address %p Routine %p\n",
  71                       ExceptRec,
  72                       Context,
  73                       ExceptRec->ExceptionCode,
  74                       ExceptRec->ExceptionAddress,
  75                       (void *)AFSExceptionFilter);
  76
  77         DbgPrint("**** Exception Caught in AFS Redirector Library ****\n");
  78
  79         DbgPrint("\n\nPerform the following WnDbg Cmds:\n");
  80         DbgPrint("\n\t.exr %p ;  .cxr %p\n\n", ExceptRec, Context);
  81
  82         DbgPrint("**** Exception Complete from AFS Redirector Library ****\n");
  83
  84         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
  85         {
  86
  87             KeBugCheck( (ULONG)-2);
  88         }
  89         else
  90         {
  91
  92             AFSBreakPoint();
  93         }
  94     }
  95     __except( EXCEPTION_EXECUTE_HANDLER)
  96     {
  97
  98         NOTHING;
  99     }
 100
 101     return EXCEPTION_EXECUTE_HANDLER;
 102 }
 103
 104 //
 105 // Function: AFSLibExAllocatePoolWithTag()
 106 //
 107 // Purpose: Allocate Pool Memory.  If BugCheck Exception flag
 108 //          is configured on, then bugcheck the system if
 109 //          a memory allocation fails.  The routine should be
 110 //          used for all memory allocations that are to be freed
 111 //          when the library is unloaded.  Memory allocations that
 112 //          are to survive library unload and reload should be
 113 //          performed using AFSExAllocatePoolWithTag() which is
 114 //          provided by the AFS Framework.
 115 //
 116 // Parameters:
 117 //                POOL_TYPE PoolType - Paged or NonPaged
 118 //                SIZE_T NumberOfBytes - requested allocation size
 119 //                ULONG  Tag - Pool Allocation Tag to be applied for tracking
 120 //
 121 // Return:
 122 //                void * - the memory allocation
 123 //
 124
 125 void *
 126 AFSLibExAllocatePoolWithTag( IN POOL_TYPE  PoolType,
 127                              IN SIZE_T  NumberOfBytes,
 128                              IN ULONG  Tag)
 129 {
 130
 131     void *pBuffer = NULL;
 132
 133     pBuffer = ExAllocatePoolWithTag( PoolType,
 134                                      NumberOfBytes,
 135                                      Tag);
 136
 137     if( pBuffer == NULL)
 138     {
 139
 140         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
 141         {
 142
 143             KeBugCheck( (ULONG)-2);
 144         }
 145         else
 146         {
 147
 148             AFSDbgLogMsg( 0,
 149                           0,
 150                           "AFSLibExAllocatePoolWithTag failure Type %08lX Size %08lX Tag %08lX %08lX\n",
 151                           PoolType,
 152                           NumberOfBytes,
 153                           Tag,
 154                           PsGetCurrentThread());
 155
 156             AFSBreakPoint();
 157         }
 158     }
 159
 160     return pBuffer;
 161 }
 162
 163 //
 164 // Function: AFSAcquireExcl()
 165 //
 166 // Purpose: Called to acquire a resource exclusive with optional wait
 167 //
 168 // Parameters:
 169 //                PERESOURCE Resource - Resource to acquire
 170 //                BOOLEAN Wait - Whether to block
 171 //
 172 // Return:
 173 //                BOOLEAN - Whether the mask was acquired
 174 //
 175
 176 BOOLEAN
 177 AFSAcquireExcl( IN PERESOURCE Resource,
 178                 IN BOOLEAN wait)
 179 {
 180
 181     BOOLEAN bStatus = FALSE;
 182
 183     //
 184     // Normal kernel APCs must be disabled before calling
 185     // ExAcquireResourceExclusiveLite. Otherwise a bugcheck occurs.
 186     //
 187
 188     KeEnterCriticalRegion();
 189
 190     bStatus = ExAcquireResourceExclusiveLite( Resource,
 191                                               wait);
 192
 193     if( !bStatus)
 194     {
 195
 196         KeLeaveCriticalRegion();
 197     }
 198
 199     return bStatus;
 200 }
 201
 202 BOOLEAN
 203 AFSAcquireSharedStarveExclusive( IN PERESOURCE Resource,
 204                                  IN BOOLEAN Wait)
 205 {
 206
 207     BOOLEAN bStatus = FALSE;
 208
 209     KeEnterCriticalRegion();
 210
 211     bStatus = ExAcquireSharedStarveExclusive( Resource,
 212                                               Wait);
 213
 214     if( !bStatus)
 215     {
 216
 217         KeLeaveCriticalRegion();
 218     }
 219
 220     return bStatus;
 221 }
 222
 223 //
 224 // Function: AFSAcquireShared()
 225 //
 226 // Purpose: Called to acquire a resource shared with optional wait
 227 //
 228 // Parameters:
 229 //                PERESOURCE Resource - Resource to acquire
 230 //                BOOLEAN Wait - Whether to block
 231 //
 232 // Return:
 233 //                BOOLEAN - Whether the mask was acquired
 234 //
 235
 236 BOOLEAN
 237 AFSAcquireShared( IN PERESOURCE Resource,
 238                   IN BOOLEAN wait)
 239 {
 240
 241     BOOLEAN bStatus = FALSE;
 242
 243     KeEnterCriticalRegion();
 244
 245     bStatus = ExAcquireResourceSharedLite( Resource,
 246                                            wait);
 247
 248     if( !bStatus)
 249     {
 250
 251         KeLeaveCriticalRegion();
 252     }
 253
 254     return bStatus;
 255 }
 256
 257 //
 258 // Function: AFSReleaseResource()
 259 //
 260 // Purpose: Called to release a resource
 261 //
 262 // Parameters:
 263 //                PERESOURCE Resource - Resource to release
 264 //
 265 // Return:
 266 //                None
 267 //
 268
 269 void
 270 AFSReleaseResource( IN PERESOURCE Resource)
 271 {
 272
 273     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 274                   AFS_TRACE_LEVEL_VERBOSE,
 275                   "AFSReleaseResource Releasing lock %08lX Thread %08lX\n",
 276                   Resource,
 277                   PsGetCurrentThread());
 278
 279     ExReleaseResourceLite( Resource);
 280
 281     KeLeaveCriticalRegion();
 282
 283     return;
 284 }
 285
 286 void
 287 AFSConvertToShared( IN PERESOURCE Resource)
 288 {
 289
 290     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 291                   AFS_TRACE_LEVEL_VERBOSE,
 292                   "AFSConvertToShared Converting lock %08lX Thread %08lX\n",
 293                   Resource,
 294                   PsGetCurrentThread());
 295
 296     ExConvertExclusiveToSharedLite( Resource);
 297
 298     return;
 299 }
 300
 301 //
 302 // Function: AFSCompleteRequest
 303 //
 304 // Description:
 305 //
 306 //      This function completes irps
 307 //
 308 // Return:
 309 //
 310 //      A status is returned for the function
 311 //
 312
 313 void
 314 AFSCompleteRequest( IN PIRP Irp,
 315                     IN ULONG Status)
 316 {
 317
 318     Irp->IoStatus.Status = Status;
 319
 320     IoCompleteRequest( Irp,
 321                        IO_NO_INCREMENT);
 322
 323     return;
 324 }
 325
 326 //
 327 // Function: AFSGenerateCRC
 328 //
 329 // Description:
 330 //
 331 //      Given a device and filename this function generates a CRC
 332 //
 333 // Return:
 334 //
 335 //      A status is returned for the function
 336 //
 337
 338 ULONG
 339 AFSGenerateCRC( IN PUNICODE_STRING FileName,
 340                 IN BOOLEAN UpperCaseName)
 341 {
 342
 343     ULONG ulCRC = 0;
 344     NTSTATUS ntStatus = STATUS_SUCCESS;
 345
 346     ntStatus = RtlHashUnicodeString( FileName,
 347                                      UpperCaseName,
 348                                      HASH_STRING_ALGORITHM_DEFAULT,
 349                                      &ulCRC);
 350
 351     if( !NT_SUCCESS( ntStatus))
 352     {
 353         ulCRC = 0;
 354     }
 355
 356     return ulCRC;
 357 }
 358
 359 void *
 360 AFSLockSystemBuffer( IN PIRP Irp,
 361                      IN ULONG Length)
 362 {
 363
 364     NTSTATUS Status = STATUS_SUCCESS;
 365     void *pAddress = NULL;
 366
 367     if( Irp->MdlAddress != NULL)
 368     {
 369
 370         pAddress = MmGetSystemAddressForMdlSafe( Irp->MdlAddress,
 371                                                  NormalPagePriority);
 372     }
 373     else if( Irp->AssociatedIrp.SystemBuffer != NULL)
 374     {
 375
 376         pAddress = Irp->AssociatedIrp.SystemBuffer;
 377     }
 378     else if( Irp->UserBuffer != NULL)
 379     {
 380
 381         Irp->MdlAddress = IoAllocateMdl( Irp->UserBuffer,
 382                                          Length,
 383                                          FALSE,
 384                                          FALSE,
 385                                          Irp);
 386
 387         if( Irp->MdlAddress != NULL)
 388         {
 389
 390             //
 391             //  Lock the new Mdl in memory.
 392             //
 393
 394             __try
 395             {
 396                 PIO_STACK_LOCATION pIoStack;
 397                 pIoStack = IoGetCurrentIrpStackLocation( Irp);
 398
 399
 400                 MmProbeAndLockPages( Irp->MdlAddress, KernelMode,
 401                                      (pIoStack->MajorFunction == IRP_MJ_READ) ? IoWriteAccess : IoReadAccess);
 402
 403                 pAddress = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
 404
 405             }
 406             __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
 407             {
 408
 409                 IoFreeMdl( Irp->MdlAddress );
 410                 Irp->MdlAddress = NULL;
 411                 pAddress = NULL;
 412             }
 413         }
 414     }
 415
 416     return pAddress;
 417 }
 418
 419 void *
 420 AFSLockUserBuffer( IN void *UserBuffer,
 421                    IN ULONG BufferLength,
 422                                    OUT MDL ** Mdl)
 423 {
 424
 425     NTSTATUS ntStatus = STATUS_SUCCESS;
 426     void *pAddress = NULL;
 427         MDL *pMdl = NULL;
 428
 429         __Enter
 430         {
 431
 432         pMdl = IoAllocateMdl( UserBuffer,
 433                               BufferLength,
 434                               FALSE,
 435                               FALSE,
 436                               NULL);
 437
 438                 if( pMdl == NULL)
 439                 {
 440
 441                         try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 442                 }
 443
 444         //
 445         //  Lock the new Mdl in memory.
 446         //
 447
 448         __try
 449         {
 450
 451             MmProbeAndLockPages( pMdl,
 452                                                                  KernelMode,
 453                                  IoWriteAccess);
 454
 455             pAddress = MmGetSystemAddressForMdlSafe( pMdl,
 456                                                                                                          NormalPagePriority);
 457         }
 458         __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
 459         {
 460
 461             IoFreeMdl( pMdl);
 462             pMdl = NULL;
 463             pAddress = NULL;
 464         }
 465
 466                 if( pMdl != NULL)
 467                 {
 468
 469                         *Mdl = pMdl;
 470                 }
 471
 472 try_exit:
 473
 474         NOTHING;
 475     }
 476
 477     return pAddress;
 478 }
 479
 480 void *
 481 AFSMapToService( IN PIRP Irp,
 482                  IN ULONG ByteCount)
 483 {
 484
 485     NTSTATUS ntStatus = STATUS_SUCCESS;
 486     void *pMappedBuffer = NULL;
 487     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 488     KAPC stApcState;
 489
 490     __Enter
 491     {
 492
 493         if( pDevExt->Specific.Control.ServiceProcess == NULL)
 494         {
 495
 496             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
 497         }
 498
 499         if( Irp->MdlAddress == NULL)
 500         {
 501
 502             if( AFSLockSystemBuffer( Irp,
 503                                      ByteCount) == NULL)
 504             {
 505
 506                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 507             }
 508         }
 509
 510         //
 511         // Attach to the service process for mapping
 512         //
 513
 514         KeStackAttachProcess( pDevExt->Specific.Control.ServiceProcess,
 515                               (PRKAPC_STATE)&stApcState);
 516
 517         pMappedBuffer = MmMapLockedPagesSpecifyCache( Irp->MdlAddress,
 518                                                       UserMode,
 519                                                       MmCached,
 520                                                       NULL,
 521                                                       FALSE,
 522                                                       NormalPagePriority);
 523
 524         KeUnstackDetachProcess( (PRKAPC_STATE)&stApcState);
 525
 526 try_exit:
 527
 528         NOTHING;
 529     }
 530
 531     return pMappedBuffer;
 532 }
 533
 534 NTSTATUS
 535 AFSUnmapServiceMappedBuffer( IN void *MappedBuffer,
 536                              IN PMDL Mdl)
 537 {
 538
 539     NTSTATUS ntStatus = STATUS_SUCCESS;
 540     void *pMappedBuffer = NULL;
 541     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 542     KAPC stApcState;
 543
 544     __Enter
 545     {
 546
 547         if( pDevExt->Specific.Control.ServiceProcess == NULL)
 548         {
 549
 550             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
 551         }
 552
 553         if( Mdl != NULL)
 554         {
 555
 556             //
 557             // Attach to the service process for mapping
 558             //
 559
 560             KeStackAttachProcess( pDevExt->Specific.Control.ServiceProcess,
 561                                   (PRKAPC_STATE)&stApcState);
 562
 563             MmUnmapLockedPages( MappedBuffer,
 564                                 Mdl);
 565
 566             KeUnstackDetachProcess( (PRKAPC_STATE)&stApcState);
 567         }
 568
 569 try_exit:
 570
 571         NOTHING;
 572     }
 573
 574     return ntStatus;
 575 }
 576
 577 NTSTATUS
 578 AFSInitializeLibraryDevice()
 579 {
 580
 581     NTSTATUS ntStatus = STATUS_SUCCESS;
 582     AFSDeviceExt *pDeviceExt = NULL;
 583
 584     __Enter
 585     {
 586
 587         pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 588
 589         //
 590         // The PIOCtl file name
 591         //
 592
 593         RtlInitUnicodeString( &AFSPIOCtlName,
 594                               AFS_PIOCTL_FILE_INTERFACE_NAME);
 595
 596         //
 597         // And the global root share name
 598         //
 599
 600         RtlInitUnicodeString( &AFSGlobalRootName,
 601                               AFS_GLOBAL_ROOT_SHARE_NAME);
 602
 603     }
 604
 605     return ntStatus;
 606 }
 607
 608 NTSTATUS
 609 AFSRemoveLibraryDevice()
 610 {
 611
 612     NTSTATUS ntStatus = STATUS_SUCCESS;
 613
 614     __Enter
 615     {
 616
 617     }
 618
 619     return ntStatus;
 620 }
 621
 622 NTSTATUS
 623 AFSDefaultDispatch( IN PDEVICE_OBJECT DeviceObject,
 624                     IN PIRP Irp)
 625 {
 626
 627     NTSTATUS            ntStatus = STATUS_INVALID_DEVICE_REQUEST;
 628     PIO_STACK_LOCATION  pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 629
 630     AFSCompleteRequest( Irp,
 631                         ntStatus);
 632
 633     return ntStatus;
 634 }
 635
 636 NTSTATUS
 637 AFSInitializeGlobalDirectoryEntries()
 638 {
 639
 640     NTSTATUS ntStatus = STATUS_SUCCESS;
 641     AFSDirectoryCB *pDirNode = NULL;
 642     ULONG ulEntryLength = 0;
 643     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 644     AFSObjectInfoCB *pObjectInfoCB = NULL;
 645     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
 646
 647     __Enter
 648     {
 649
 650         //
 651         // Initialize the global . entry
 652         //
 653
 654         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
 655                                                0);
 656
 657         if( pObjectInfoCB == NULL)
 658         {
 659
 660             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 661                           AFS_TRACE_LEVEL_ERROR,
 662                           "AFSInitializeGlobalDirectory AFSAllocateObjectInfo failure %08lX\n",
 663                           ntStatus);
 664
 665             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 666         }
 667
 668         InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 669
 670         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 671                       AFS_TRACE_LEVEL_VERBOSE,
 672                       "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
 673                       pObjectInfoCB,
 674                       pObjectInfoCB->ObjectReferenceCount);
 675
 676         ntStatus = STATUS_SUCCESS;
 677
 678         ulEntryLength = sizeof( AFSDirectoryCB) +
 679                                      sizeof( WCHAR);
 680
 681         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
 682                                                                   ulEntryLength,
 683                                                                   AFS_DIR_ENTRY_TAG);
 684
 685         if( pDirNode == NULL)
 686         {
 687
 688             AFSDeleteObjectInfo( pObjectInfoCB);
 689
 690             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 691                           AFS_TRACE_LEVEL_ERROR,
 692                           "AFSInitializeGlobalDirectory AFS_DIR_ENTRY_TAG allocation failure\n");
 693
 694             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 695         }
 696
 697         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
 698                                                                                    sizeof( AFSNonPagedDirectoryCB),
 699                                                                                    AFS_DIR_ENTRY_NP_TAG);
 700
 701         if( pNonPagedDirEntry == NULL)
 702         {
 703
 704             ExFreePool( pDirNode);
 705
 706             AFSDeleteObjectInfo( pObjectInfoCB);
 707
 708             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 709                           AFS_TRACE_LEVEL_ERROR,
 710                           "AFSInitializeGlobalDirectory AFS_DIR_ENTRY_NP_TAG allocation failure\n");
 711
 712             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 713         }
 714
 715         RtlZeroMemory( pDirNode,
 716                        ulEntryLength);
 717
 718         RtlZeroMemory( pNonPagedDirEntry,
 719                        sizeof( AFSNonPagedDirectoryCB));
 720
 721         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
 722
 723         pDirNode->NonPaged = pNonPagedDirEntry;
 724
 725         pDirNode->ObjectInformation = pObjectInfoCB;
 726
 727         //
 728         // Set valid entry
 729         //
 730
 731         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE | AFS_DIR_ENTRY_FAKE | AFS_DIR_ENTRY_VALID);
 732
 733         pDirNode->FileIndex = (ULONG)AFS_DIR_ENTRY_DOT_INDEX;
 734
 735         //
 736         // Setup the names in the entry
 737         //
 738
 739         pDirNode->NameInformation.FileName.Length = sizeof( WCHAR);
 740
 741         pDirNode->NameInformation.FileName.MaximumLength = sizeof( WCHAR);
 742
 743         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
 744
 745         pDirNode->NameInformation.FileName.Buffer[ 0] = L'.';
 746
 747         //
 748         // Populate the rest of the data
 749         //
 750
 751         pObjectInfoCB->FileType = AFS_FILE_TYPE_DIRECTORY;
 752
 753         pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 754
 755         AFSGlobalDotDirEntry = pDirNode;
 756
 757         //
 758         // Now the .. entry
 759         //
 760
 761         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
 762                                                0);
 763
 764         if( pObjectInfoCB == NULL)
 765         {
 766
 767             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 768                           AFS_TRACE_LEVEL_ERROR,
 769                           "AFSInitializeGlobalDirectory AFSAllocateObjectInfo (2) failure %08lX\n",
 770                           ntStatus);
 771
 772             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 773         }
 774
 775         InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 776
 777         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 778                       AFS_TRACE_LEVEL_VERBOSE,
 779                       "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
 780                       pObjectInfoCB,
 781                       pObjectInfoCB->ObjectReferenceCount);
 782
 783         ntStatus = STATUS_SUCCESS;
 784
 785         ulEntryLength = sizeof( AFSDirectoryCB) +
 786                                      ( 2 * sizeof( WCHAR));
 787
 788         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
 789                                                                   ulEntryLength,
 790                                                                   AFS_DIR_ENTRY_TAG);
 791
 792         if( pDirNode == NULL)
 793         {
 794
 795             AFSDeleteObjectInfo( pObjectInfoCB);
 796
 797             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 798         }
 799
 800         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
 801                                                                                    sizeof( AFSNonPagedDirectoryCB),
 802                                                                                    AFS_DIR_ENTRY_NP_TAG);
 803
 804         if( pNonPagedDirEntry == NULL)
 805         {
 806
 807             ExFreePool( pDirNode);
 808
 809             AFSDeleteObjectInfo( pObjectInfoCB);
 810
 811             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 812         }
 813
 814         RtlZeroMemory( pDirNode,
 815                        ulEntryLength);
 816
 817         RtlZeroMemory( pNonPagedDirEntry,
 818                        sizeof( AFSNonPagedDirectoryCB));
 819
 820         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
 821
 822         pDirNode->NonPaged = pNonPagedDirEntry;
 823
 824         pDirNode->ObjectInformation = pObjectInfoCB;
 825
 826         //
 827         // Set valid entry
 828         //
 829
 830         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE | AFS_DIR_ENTRY_FAKE | AFS_DIR_ENTRY_VALID);
 831
 832         pDirNode->FileIndex = (ULONG)AFS_DIR_ENTRY_DOT_DOT_INDEX;
 833
 834         //
 835         // Setup the names in the entry
 836         //
 837
 838         pDirNode->NameInformation.FileName.Length = 2 * sizeof( WCHAR);
 839
 840         pDirNode->NameInformation.FileName.MaximumLength = 2 * sizeof( WCHAR);
 841
 842         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
 843
 844         pDirNode->NameInformation.FileName.Buffer[ 0] = L'.';
 845
 846         pDirNode->NameInformation.FileName.Buffer[ 1] = L'.';
 847
 848         //
 849         // Populate the rest of the data
 850         //
 851
 852         pObjectInfoCB->FileType = AFS_FILE_TYPE_DIRECTORY;
 853
 854         pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 855
 856         AFSGlobalDotDotDirEntry = pDirNode;
 857
 858 try_exit:
 859
 860         if( !NT_SUCCESS( ntStatus))
 861         {
 862
 863             if( AFSGlobalDotDirEntry != NULL)
 864             {
 865
 866                 AFSDeleteObjectInfo( AFSGlobalDotDirEntry->ObjectInformation);
 867
 868                 ExDeleteResourceLite( &AFSGlobalDotDirEntry->NonPaged->Lock);
 869
 870                 ExFreePool( AFSGlobalDotDirEntry->NonPaged);
 871
 872                 ExFreePool( AFSGlobalDotDirEntry);
 873
 874                 AFSGlobalDotDirEntry = NULL;
 875             }
 876
 877             if( AFSGlobalDotDotDirEntry != NULL)
 878             {
 879
 880                 AFSDeleteObjectInfo( AFSGlobalDotDotDirEntry->ObjectInformation);
 881
 882                 ExDeleteResourceLite( &AFSGlobalDotDotDirEntry->NonPaged->Lock);
 883
 884                 ExFreePool( AFSGlobalDotDotDirEntry->NonPaged);
 885
 886                 ExFreePool( AFSGlobalDotDotDirEntry);
 887
 888                 AFSGlobalDotDotDirEntry = NULL;
 889             }
 890         }
 891     }
 892
 893     return ntStatus;
 894 }
 895
 896 AFSDirectoryCB *
 897 AFSInitDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
 898                  IN PUNICODE_STRING FileName,
 899                  IN PUNICODE_STRING TargetName,
 900                  IN AFSDirEnumEntry *DirEnumEntry,
 901                  IN ULONG FileIndex)
 902 {
 903
 904     AFSDirectoryCB *pDirNode = NULL;
 905     NTSTATUS ntStatus = STATUS_SUCCESS;
 906     ULONG ulEntryLength = 0;
 907     AFSDirEnumEntry *pDirEnumCB = NULL;
 908     AFSFileID stTargetFileID;
 909     AFSFcb *pVcb = NULL;
 910     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 911     AFSObjectInfoCB *pObjectInfoCB = NULL;
 912     BOOLEAN bAllocatedObjectCB = FALSE;
 913     ULONGLONG ullIndex = 0;
 914     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
 915
 916     __Enter
 917     {
 918
 919         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 920                       AFS_TRACE_LEVEL_VERBOSE,
 921                       "AFSInitDirEntry Initializing entry %wZ parent FID %08lX-%08lX-%08lX-%08lX\n",
 922                       FileName,
 923                       ParentObjectInfo->FileId.Cell,
 924                       ParentObjectInfo->FileId.Volume,
 925                       ParentObjectInfo->FileId.Vnode,
 926                       ParentObjectInfo->FileId.Unique);
 927
 928         //
 929         // First thing is to locate/create our object information block
 930         // for this entry
 931         //
 932
 933         AFSAcquireExcl( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
 934                         TRUE);
 935
 936         ullIndex = AFSCreateLowIndex( &DirEnumEntry->FileId);
 937
 938         ntStatus = AFSLocateHashEntry( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
 939                                        ullIndex,
 940                                        (AFSBTreeEntry **)&pObjectInfoCB);
 941
 942         if( !NT_SUCCESS( ntStatus) ||
 943             pObjectInfoCB == NULL)
 944         {
 945
 946             //
 947             // Allocate our object info cb
 948             //
 949
 950             pObjectInfoCB = AFSAllocateObjectInfo( ParentObjectInfo,
 951                                                    ullIndex);
 952
 953             if( pObjectInfoCB == NULL)
 954             {
 955
 956                 AFSReleaseResource( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
 957
 958                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 959             }
 960
 961             bAllocatedObjectCB = TRUE;
 962
 963             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 964                           AFS_TRACE_LEVEL_VERBOSE,
 965                           "AFSInitDirEntry initialized object %08lX Parent Object %08lX for %wZ\n",
 966                           pObjectInfoCB,
 967                           ParentObjectInfo,
 968                           FileName);
 969         }
 970
 971         InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 972
 973         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 974                       AFS_TRACE_LEVEL_VERBOSE,
 975                       "AFSInitDirEntry Increment count on object %08lX Cnt %d\n",
 976                       pObjectInfoCB,
 977                       pObjectInfoCB->ObjectReferenceCount);
 978
 979         AFSReleaseResource( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
 980
 981         ntStatus = STATUS_SUCCESS;
 982
 983         ulEntryLength = sizeof( AFSDirectoryCB) +
 984                                      FileName->Length;
 985
 986         if( TargetName != NULL)
 987         {
 988
 989             ulEntryLength += TargetName->Length;
 990         }
 991
 992         pDirNode = (AFSDirectoryCB *)AFSExAllocatePoolWithTag( PagedPool,
 993                                                                ulEntryLength,
 994                                                                AFS_DIR_ENTRY_TAG);
 995
 996         if( pDirNode == NULL)
 997         {
 998
 999             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1000         }
1001
1002         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
1003                                                                                 sizeof( AFSNonPagedDirectoryCB),
1004                                                                                 AFS_DIR_ENTRY_NP_TAG);
1005
1006         if( pNonPagedDirEntry == NULL)
1007         {
1008
1009             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1010         }
1011
1012         RtlZeroMemory( pDirNode,
1013                        ulEntryLength);
1014
1015         RtlZeroMemory( pNonPagedDirEntry,
1016                        sizeof( AFSNonPagedDirectoryCB));
1017
1018         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
1019
1020         pDirNode->NonPaged = pNonPagedDirEntry;
1021
1022         pDirNode->ObjectInformation = pObjectInfoCB;
1023
1024         //
1025         // Set valid entry
1026         //
1027
1028         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID);
1029
1030         pDirNode->FileIndex = FileIndex;
1031
1032         //
1033         // Setup the names in the entry
1034         //
1035
1036         if( FileName->Length > 0)
1037         {
1038
1039             pDirNode->NameInformation.FileName.Length = FileName->Length;
1040
1041             pDirNode->NameInformation.FileName.MaximumLength = FileName->Length;
1042
1043             pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
1044
1045             RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
1046                            FileName->Buffer,
1047                            pDirNode->NameInformation.FileName.Length);
1048
1049             //
1050             // Create a CRC for the file
1051             //
1052
1053             pDirNode->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
1054                                                                          FALSE);
1055
1056             pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
1057                                                                            TRUE);
1058         }
1059
1060         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1061                       AFS_TRACE_LEVEL_VERBOSE,
1062                       "AFSInitDirEntry Initialized DE %p for %wZ in parent FID %08lX-%08lX-%08lX-%08lX\n",
1063                       pDirNode,
1064                       FileName,
1065                       ParentObjectInfo->FileId.Cell,
1066                       ParentObjectInfo->FileId.Volume,
1067                       ParentObjectInfo->FileId.Vnode,
1068                       ParentObjectInfo->FileId.Unique);
1069
1070         if( TargetName != NULL &&
1071             TargetName->Length > 0)
1072         {
1073
1074             pDirNode->NameInformation.TargetName.Length = TargetName->Length;
1075
1076             pDirNode->NameInformation.TargetName.MaximumLength = pDirNode->NameInformation.TargetName.Length;
1077
1078             pDirNode->NameInformation.TargetName.Buffer = (WCHAR *)((char *)pDirNode +
1079                                                                             sizeof( AFSDirectoryCB) +
1080                                                                             pDirNode->NameInformation.FileName.Length);
1081
1082             RtlCopyMemory( pDirNode->NameInformation.TargetName.Buffer,
1083                            TargetName->Buffer,
1084                            pDirNode->NameInformation.TargetName.Length);
1085         }
1086
1087         //
1088         // If we allocated the object information cb then update the information
1089         //
1090
1091         if( bAllocatedObjectCB)
1092         {
1093
1094             //
1095             // Populate the rest of the data
1096             //
1097
1098             pObjectInfoCB->FileId = DirEnumEntry->FileId;
1099
1100             pObjectInfoCB->TargetFileId = DirEnumEntry->TargetFileId;
1101
1102             pObjectInfoCB->FileType = DirEnumEntry->FileType;
1103
1104             pObjectInfoCB->CreationTime = DirEnumEntry->CreationTime;
1105
1106             pObjectInfoCB->LastAccessTime = DirEnumEntry->LastAccessTime;
1107
1108             pObjectInfoCB->LastWriteTime = DirEnumEntry->LastWriteTime;
1109
1110             pObjectInfoCB->ChangeTime = DirEnumEntry->ChangeTime;
1111
1112             pObjectInfoCB->EndOfFile = DirEnumEntry->EndOfFile;
1113
1114             pObjectInfoCB->AllocationSize = DirEnumEntry->AllocationSize;
1115
1116             pObjectInfoCB->FileAttributes = DirEnumEntry->FileAttributes;
1117
1118             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
1119                 pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK ||
1120                 pObjectInfoCB->FileType == AFS_FILE_TYPE_DFSLINK)
1121             {
1122
1123                 pObjectInfoCB->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
1124             }
1125
1126             pObjectInfoCB->EaSize = DirEnumEntry->EaSize;
1127
1128             //
1129             // Object specific information
1130             //
1131
1132             pObjectInfoCB->Links = DirEnumEntry->Links;
1133
1134             pObjectInfoCB->Expiration = DirEnumEntry->Expiration;
1135
1136             pObjectInfoCB->DataVersion = DirEnumEntry->DataVersion;
1137
1138             //
1139             // Check for the case where we have a filetype of SymLink but both the TargetFid and the
1140             // TargetName are empty. In this case set the filetype to zero so we evaluate it later in
1141             // the code
1142             //
1143
1144             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK &&
1145                 pObjectInfoCB->TargetFileId.Vnode == 0 &&
1146                 pObjectInfoCB->TargetFileId.Unique == 0 &&
1147                 pDirNode->NameInformation.TargetName.Length == 0)
1148             {
1149
1150                 //
1151                 // This will ensure we perform a validation on the node
1152                 //
1153
1154                 pObjectInfoCB->FileType = AFS_FILE_TYPE_UNKNOWN;
1155             }
1156
1157             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_UNKNOWN)
1158             {
1159
1160                 SetFlag( pObjectInfoCB->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
1161             }
1162         }
1163
1164 try_exit:
1165
1166         if( !NT_SUCCESS( ntStatus))
1167         {
1168
1169             if( pNonPagedDirEntry != NULL)
1170             {
1171
1172                 ExDeleteResourceLite( &pNonPagedDirEntry->Lock);
1173
1174                 AFSExFreePool( pNonPagedDirEntry);
1175             }
1176
1177             if( pDirNode != NULL)
1178             {
1179
1180                 AFSExFreePool( pDirNode);
1181
1182                 pDirNode = NULL;
1183             }
1184
1185             //
1186             // Dereference our object info block if we have one
1187             //
1188
1189             if( pObjectInfoCB != NULL)
1190             {
1191
1192                 InterlockedDecrement( &pObjectInfoCB->ObjectReferenceCount);
1193
1194                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1195                               AFS_TRACE_LEVEL_VERBOSE,
1196                               "AFSInitDirEntry Decrement count on object %08lX Cnt %d\n",
1197                               pObjectInfoCB,
1198                               pObjectInfoCB->ObjectReferenceCount);
1199
1200                 if( bAllocatedObjectCB)
1201                 {
1202
1203                     ASSERT( pObjectInfoCB->ObjectReferenceCount == 0);
1204
1205                     AFSDeleteObjectInfo( pObjectInfoCB);
1206                 }
1207             }
1208         }
1209     }
1210
1211     return pDirNode;
1212 }
1213
1214 BOOLEAN
1215 AFSCheckForReadOnlyAccess( IN ACCESS_MASK DesiredAccess,
1216                            IN BOOLEAN DirectoryEntry)
1217 {
1218
1219     BOOLEAN bReturn = TRUE;
1220     ACCESS_MASK stAccessMask = 0;
1221
1222     //
1223     // Get rid of anything we don't know about
1224     //
1225
1226     DesiredAccess = (DesiredAccess   &
1227                           ( DELETE |
1228                             READ_CONTROL |
1229                             WRITE_OWNER |
1230                             WRITE_DAC |
1231                             SYNCHRONIZE |
1232                             ACCESS_SYSTEM_SECURITY |
1233                             FILE_WRITE_DATA |
1234                             FILE_READ_EA |
1235                             FILE_WRITE_EA |
1236                             FILE_READ_ATTRIBUTES |
1237                             FILE_WRITE_ATTRIBUTES |
1238                             FILE_LIST_DIRECTORY |
1239                             FILE_TRAVERSE |
1240                             FILE_DELETE_CHILD |
1241                             FILE_APPEND_DATA));
1242
1243     //
1244     // Our 'read only' access mask. These are the accesses we will
1245     // allow for a read only file
1246     //
1247
1248     stAccessMask = DELETE |
1249                         READ_CONTROL |
1250                         WRITE_OWNER |
1251                         WRITE_DAC |
1252                         SYNCHRONIZE |
1253                         ACCESS_SYSTEM_SECURITY |
1254                         FILE_READ_DATA |
1255                         FILE_READ_EA |
1256                         FILE_WRITE_EA |
1257                         FILE_READ_ATTRIBUTES |
1258                         FILE_WRITE_ATTRIBUTES |
1259                         FILE_EXECUTE |
1260                         FILE_LIST_DIRECTORY |
1261                         FILE_TRAVERSE;
1262
1263     //
1264     // For a directory, add in the directory specific accesses
1265     //
1266
1267     if( DirectoryEntry)
1268     {
1269
1270         stAccessMask |= FILE_ADD_SUBDIRECTORY |
1271                                 FILE_ADD_FILE |
1272                                 FILE_DELETE_CHILD;
1273     }
1274
1275     if( FlagOn( DesiredAccess, ~stAccessMask))
1276     {
1277
1278         //
1279         // A write access is set ...
1280         //
1281
1282         bReturn = FALSE;
1283     }
1284
1285     return bReturn;
1286 }
1287
1288 NTSTATUS
1289 AFSEvaluateNode( IN GUID *AuthGroup,
1290                  IN AFSDirectoryCB *DirEntry)
1291 {
1292
1293     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1294     NTSTATUS ntStatus = STATUS_SUCCESS;
1295     AFSDirEnumEntry *pDirEntry = NULL;
1296     UNICODE_STRING uniTargetName;
1297
1298     __Enter
1299     {
1300
1301         ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
1302                                           AuthGroup,
1303                                           FALSE,
1304                                           &pDirEntry);
1305
1306         if( !NT_SUCCESS( ntStatus))
1307         {
1308
1309             try_return( ntStatus);
1310         }
1311
1312         DirEntry->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
1313
1314         DirEntry->ObjectInformation->Expiration = pDirEntry->Expiration;
1315
1316         DirEntry->ObjectInformation->DataVersion = pDirEntry->DataVersion;
1317
1318         DirEntry->ObjectInformation->FileType = pDirEntry->FileType;
1319
1320         DirEntry->ObjectInformation->CreationTime = pDirEntry->CreationTime;
1321
1322         DirEntry->ObjectInformation->LastAccessTime = pDirEntry->LastAccessTime;
1323
1324         DirEntry->ObjectInformation->LastWriteTime = pDirEntry->LastWriteTime;
1325
1326         DirEntry->ObjectInformation->ChangeTime = pDirEntry->ChangeTime;
1327
1328         DirEntry->ObjectInformation->EndOfFile = pDirEntry->EndOfFile;
1329
1330         DirEntry->ObjectInformation->AllocationSize = pDirEntry->AllocationSize;
1331
1332         DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
1333
1334         if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
1335             pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
1336             pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
1337         {
1338
1339             DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
1340         }
1341
1342         DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
1343
1344         DirEntry->ObjectInformation->Links = pDirEntry->Links;
1345
1346         //
1347         // If we have a target name then see if it needs updating ...
1348         //
1349
1350         if( pDirEntry->TargetNameLength > 0)
1351         {
1352
1353             //
1354             // Update the target name information if needed
1355             //
1356
1357             uniTargetName.Length = (USHORT)pDirEntry->TargetNameLength;
1358
1359             uniTargetName.MaximumLength = uniTargetName.Length;
1360
1361             uniTargetName.Buffer = (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset);
1362
1363             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
1364                             TRUE);
1365
1366             if( DirEntry->NameInformation.TargetName.Length == 0 ||
1367                 RtlCompareUnicodeString( &uniTargetName,
1368                                          &DirEntry->NameInformation.TargetName,
1369                                          TRUE) != 0)
1370             {
1371
1372                 //
1373                 // Update the target name
1374                 //
1375
1376                 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
1377                                                 &DirEntry->Flags,
1378                                                 uniTargetName.Buffer,
1379                                                 uniTargetName.Length);
1380
1381                 if( !NT_SUCCESS( ntStatus))
1382                 {
1383
1384                     AFSReleaseResource( &DirEntry->NonPaged->Lock);
1385
1386                     try_return( ntStatus);
1387                 }
1388             }
1389
1390             AFSReleaseResource( &DirEntry->NonPaged->Lock);
1391         }
1392
1393 try_exit:
1394
1395         if( pDirEntry != NULL)
1396         {
1397
1398             AFSExFreePool( pDirEntry);
1399         }
1400     }
1401
1402     return ntStatus;
1403 }
1404
1405 NTSTATUS
1406 AFSValidateSymLink( IN GUID *AuthGroup,
1407                     IN AFSDirectoryCB *DirEntry)
1408 {
1409
1410     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1411     NTSTATUS ntStatus = STATUS_SUCCESS;
1412     AFSDirEnumEntry *pDirEntry = NULL;
1413     UNICODE_STRING uniTargetName;
1414
1415     __Enter
1416     {
1417
1418         ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
1419                                           AuthGroup,
1420                                           FALSE,
1421                                           &pDirEntry);
1422
1423         if( !NT_SUCCESS( ntStatus))
1424         {
1425
1426             try_return( ntStatus);
1427         }
1428
1429         if( pDirEntry->FileType == AFS_FILE_TYPE_UNKNOWN ||
1430             pDirEntry->FileType == AFS_FILE_TYPE_INVALID)
1431         {
1432
1433             try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
1434         }
1435
1436         DirEntry->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
1437
1438         DirEntry->ObjectInformation->Expiration = pDirEntry->Expiration;
1439
1440         DirEntry->ObjectInformation->DataVersion = pDirEntry->DataVersion;
1441
1442         //
1443         // Update the target name information if needed
1444         //
1445
1446         uniTargetName.Length = (USHORT)pDirEntry->TargetNameLength;
1447
1448         uniTargetName.MaximumLength = uniTargetName.Length;
1449
1450         uniTargetName.Buffer = (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset);
1451
1452         if( uniTargetName.Length > 0)
1453         {
1454
1455             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
1456                             TRUE);
1457
1458             if( DirEntry->NameInformation.TargetName.Length == 0 ||
1459                 RtlCompareUnicodeString( &uniTargetName,
1460                                          &DirEntry->NameInformation.TargetName,
1461                                          TRUE) != 0)
1462             {
1463
1464                 //
1465                 // Update the target name
1466                 //
1467
1468                 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
1469                                                 &DirEntry->Flags,
1470                                                 uniTargetName.Buffer,
1471                                                 uniTargetName.Length);
1472
1473                 if( !NT_SUCCESS( ntStatus))
1474                 {
1475
1476                     AFSReleaseResource( &DirEntry->NonPaged->Lock);
1477
1478                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1479                 }
1480             }
1481
1482             AFSReleaseResource( &DirEntry->NonPaged->Lock);
1483         }
1484
1485         //
1486         // If the FileType is the same then nothing to do since it IS
1487         // a SymLink
1488         //
1489
1490         if( pDirEntry->FileType == DirEntry->ObjectInformation->FileType)
1491         {
1492
1493             ASSERT( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK);
1494
1495             try_return( ntStatus = STATUS_SUCCESS);
1496         }
1497
1498         DirEntry->ObjectInformation->FileType = pDirEntry->FileType;
1499
1500         DirEntry->ObjectInformation->CreationTime = pDirEntry->CreationTime;
1501
1502         DirEntry->ObjectInformation->LastAccessTime = pDirEntry->LastAccessTime;
1503
1504         DirEntry->ObjectInformation->LastWriteTime = pDirEntry->LastWriteTime;
1505
1506         DirEntry->ObjectInformation->ChangeTime = pDirEntry->ChangeTime;
1507
1508         DirEntry->ObjectInformation->EndOfFile = pDirEntry->EndOfFile;
1509
1510         DirEntry->ObjectInformation->AllocationSize = pDirEntry->AllocationSize;
1511
1512         DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
1513
1514         if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
1515             pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
1516             pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
1517         {
1518
1519             DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
1520         }
1521
1522         DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
1523
1524         DirEntry->ObjectInformation->Links = pDirEntry->Links;
1525
1526 try_exit:
1527
1528         if( pDirEntry != NULL)
1529         {
1530
1531             AFSExFreePool( pDirEntry);
1532         }
1533     }
1534
1535     return ntStatus;
1536 }
1537
1538 NTSTATUS
1539 AFSInvalidateCache( IN AFSInvalidateCacheCB *InvalidateCB)
1540 {
1541
1542     NTSTATUS ntStatus = STATUS_SUCCESS;
1543     AFSFcb      *pDcb = NULL, *pFcb = NULL, *pNextFcb = NULL;
1544     AFSVolumeCB *pVolumeCB = NULL;
1545     AFSFcb      *pTargetDcb = NULL;
1546     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
1547     AFSDirectoryCB *pCurrentDirEntry = NULL;
1548     BOOLEAN     bIsChild = FALSE;
1549     ULONGLONG   ullIndex = 0;
1550     AFSObjectInfoCB *pObjectInfo = NULL;
1551     IO_STATUS_BLOCK stIoStatus;
1552     ULONG ulFilter = 0;
1553
1554     __Enter
1555     {
1556
1557         //
1558         // Need to locate the Fcb for the directory to purge
1559         //
1560
1561         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1562                       AFS_TRACE_LEVEL_VERBOSE,
1563                       "AFSInvalidateCache Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
1564                       &pDevExt->Specific.RDR.VolumeTreeLock,
1565                       PsGetCurrentThread());
1566
1567         //
1568         // Starve any exclusive waiters on this paticular call
1569         //
1570
1571         AFSAcquireSharedStarveExclusive( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
1572
1573         //
1574         // Locate the volume node
1575         //
1576
1577         ullIndex = AFSCreateHighIndex( &InvalidateCB->FileID);
1578
1579         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
1580                                        ullIndex,
1581                                        (AFSBTreeEntry **)&pVolumeCB);
1582
1583         if( pVolumeCB != NULL)
1584         {
1585
1586             InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
1587
1588             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1589                           AFS_TRACE_LEVEL_VERBOSE,
1590                           "AFSInvalidateCache Increment count on volume %08lX Cnt %d\n",
1591                           pVolumeCB,
1592                           pVolumeCB->VolumeReferenceCount);
1593         }
1594
1595         AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
1596
1597         if( !NT_SUCCESS( ntStatus) ||
1598             pVolumeCB == NULL)
1599         {
1600             try_return( ntStatus = STATUS_SUCCESS);
1601         }
1602
1603         //
1604         // If this is a whole volume invalidation then go do it now
1605         //
1606
1607         if( InvalidateCB->WholeVolume ||
1608             AFSIsVolumeFID( &InvalidateCB->FileID))
1609         {
1610
1611             ntStatus = AFSInvalidateVolume( pVolumeCB,
1612                                             InvalidateCB->Reason);
1613
1614             AFSFsRtlNotifyFullReportChange( &pVolumeCB->ObjectInformation,
1615                                             NULL,
1616                                             FILE_NOTIFY_CHANGE_FILE_NAME |
1617                                                 FILE_NOTIFY_CHANGE_DIR_NAME |
1618                                                 FILE_NOTIFY_CHANGE_NAME |
1619                                                 FILE_NOTIFY_CHANGE_ATTRIBUTES |
1620                                                 FILE_NOTIFY_CHANGE_SIZE,
1621                                             FILE_ACTION_MODIFIED);
1622
1623             InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1624
1625             try_return( ntStatus);
1626         }
1627
1628         AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1629                           TRUE);
1630
1631         InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1632
1633         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1634                       AFS_TRACE_LEVEL_VERBOSE,
1635                       "AFSInvalidateCache Decrement count on volume %08lX Cnt %d\n",
1636                       pVolumeCB,
1637                       pVolumeCB->VolumeReferenceCount);
1638
1639         ullIndex = AFSCreateLowIndex( &InvalidateCB->FileID);
1640
1641         ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
1642                                        ullIndex,
1643                                        (AFSBTreeEntry **)&pObjectInfo);
1644
1645         if( pObjectInfo != NULL)
1646         {
1647
1648             //
1649             // Reference the node so it won't be torn down
1650             //
1651
1652             InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
1653
1654             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1655                           AFS_TRACE_LEVEL_VERBOSE,
1656                           "AFSInvalidateCache Increment count on object %08lX Cnt %d\n",
1657                           pObjectInfo,
1658                           pObjectInfo->ObjectReferenceCount);
1659         }
1660
1661         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1662
1663         if( !NT_SUCCESS( ntStatus) ||
1664             pObjectInfo == NULL)
1665         {
1666             try_return( ntStatus = STATUS_SUCCESS);
1667         }
1668
1669         if( pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK ||
1670             pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK ||
1671             pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1672         {
1673
1674             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1675                           AFS_TRACE_LEVEL_VERBOSE,
1676                           "AFSInvalidateCache Invalidation on node type %d for fid %08lX-%08lX-%08lX-%08lX Reason %d\n",
1677                           pObjectInfo->FileType,
1678                           pObjectInfo->FileId.Cell,
1679                           pObjectInfo->FileId.Volume,
1680                           pObjectInfo->FileId.Vnode,
1681                           pObjectInfo->FileId.Unique,
1682                           InvalidateCB->Reason);
1683
1684             //
1685             // We only act on the mount point itself, not the target. If the
1686             // node has been deleted then mark it as such otherwise indicate
1687             // it requires verification
1688             //
1689
1690             if( InvalidateCB->Reason == AFS_INVALIDATE_DELETED)
1691             {
1692                 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
1693             }
1694             else
1695             {
1696
1697                 if( InvalidateCB->Reason == AFS_INVALIDATE_FLUSHED ||
1698                     InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
1699                 {
1700                     pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
1701                 }
1702
1703                 pObjectInfo->Expiration.QuadPart = 0;
1704
1705                 pObjectInfo->TargetFileId.Vnode = 0;
1706
1707                 pObjectInfo->TargetFileId.Unique = 0;
1708
1709                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1710                               AFS_TRACE_LEVEL_VERBOSE,
1711                               "AFSInvalidateCache Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
1712                               pObjectInfo->FileId.Cell,
1713                               pObjectInfo->FileId.Volume,
1714                               pObjectInfo->FileId.Vnode,
1715                               pObjectInfo->FileId.Unique);
1716
1717                 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
1718             }
1719
1720             ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1721
1722             if( InvalidateCB->Reason == AFS_INVALIDATE_CREDS)
1723             {
1724                 ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
1725             }
1726
1727             if( InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
1728             {
1729                 ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
1730             }
1731             else
1732             {
1733                 ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1734             }
1735
1736             AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
1737                                             NULL,
1738                                             FILE_NOTIFY_CHANGE_FILE_NAME |
1739                                             FILE_NOTIFY_CHANGE_ATTRIBUTES,
1740                                             FILE_ACTION_MODIFIED);
1741
1742             try_return( ntStatus);
1743         }
1744
1745         //
1746         // Depending on the reason for invalidation then perform work on the node
1747         //
1748
1749         switch( InvalidateCB->Reason)
1750         {
1751
1752             case AFS_INVALIDATE_DELETED:
1753             {
1754
1755                 //
1756                 // Mark this node as invalid
1757                 //
1758
1759                 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DELETED);
1760
1761                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1762                               AFS_TRACE_LEVEL_VERBOSE,
1763                               "AFSInvalidateCache Set DELETE flag on fid %08lX-%08lX-%08lX-%08lX\n",
1764                               pObjectInfo->FileId.Cell,
1765                               pObjectInfo->FileId.Volume,
1766                               pObjectInfo->FileId.Vnode,
1767                               pObjectInfo->FileId.Unique);
1768
1769                 if( pObjectInfo->ParentObjectInformation != NULL)
1770                 {
1771
1772                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1773                                   AFS_TRACE_LEVEL_VERBOSE,
1774                                   "AFSInvalidateCache Set VERIFY flag on parent fid %08lX-%08lX-%08lX-%08lX\n",
1775                                   pObjectInfo->ParentObjectInformation->FileId.Cell,
1776                                   pObjectInfo->ParentObjectInformation->FileId.Volume,
1777                                   pObjectInfo->ParentObjectInformation->FileId.Vnode,
1778                                   pObjectInfo->ParentObjectInformation->FileId.Unique);
1779
1780                     SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
1781                     pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
1782                     pObjectInfo->ParentObjectInformation->Expiration.QuadPart = 0;
1783                 }
1784
1785                 if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
1786                 {
1787                     ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
1788                 }
1789                 else
1790                 {
1791                     ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1792                 }
1793
1794                 AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
1795                                                 NULL,
1796                                                 ulFilter,
1797                                                 FILE_ACTION_REMOVED);
1798
1799                 break;
1800             }
1801
1802             case AFS_INVALIDATE_FLUSHED:
1803             {
1804
1805                 if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE &&
1806                     pObjectInfo->Fcb != NULL)
1807                 {
1808
1809                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1810                                   AFS_TRACE_LEVEL_VERBOSE,
1811                                   "AFSInvalidateCache Flush/purge file fid %08lX-%08lX-%08lX-%08lX\n",
1812                                   pObjectInfo->FileId.Cell,
1813                                   pObjectInfo->FileId.Volume,
1814                                   pObjectInfo->FileId.Vnode,
1815                                   pObjectInfo->FileId.Unique);
1816
1817                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
1818                                     TRUE);
1819
1820                     __try
1821                     {
1822
1823                         CcFlushCache( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
1824                                       NULL,
1825                                       0,
1826                                       &stIoStatus);
1827
1828                         if( !NT_SUCCESS( stIoStatus.Status))
1829                         {
1830
1831                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1832                                           AFS_TRACE_LEVEL_ERROR,
1833                                           "AFSInvalidateCache CcFlushCache failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
1834                                           pObjectInfo->FileId.Cell,
1835                                           pObjectInfo->FileId.Volume,
1836                                           pObjectInfo->FileId.Vnode,
1837                                           pObjectInfo->FileId.Unique,
1838                                           stIoStatus.Status,
1839                                           stIoStatus.Information);
1840
1841                             ntStatus = stIoStatus.Status;
1842                         }
1843
1844                         CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
1845                                              NULL,
1846                                              0,
1847                                              FALSE);
1848                     }
1849                     __except( EXCEPTION_EXECUTE_HANDLER)
1850                     {
1851
1852                         ntStatus = GetExceptionCode();
1853                     }
1854
1855                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
1856
1857                     //
1858                     // Clear out the extents
1859                     // Get rid of them (note this involves waiting
1860                     // for any writes or reads to the cache to complete)
1861                     //
1862
1863                     (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb);
1864                 }
1865
1866                 // Fall through to the default processing
1867             }
1868
1869             default:
1870             {
1871
1872                 if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
1873                 {
1874                     ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
1875                 }
1876                 else
1877                 {
1878                     ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1879                 }
1880
1881                 if( InvalidateCB->Reason == AFS_INVALIDATE_CREDS)
1882                 {
1883                     ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
1884                 }
1885
1886                 if( InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
1887                 {
1888                     ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
1889                 }
1890                 else
1891                 {
1892                     ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1893                 }
1894
1895                 AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
1896                                                 NULL,
1897                                                 ulFilter,
1898                                                 FILE_ACTION_MODIFIED);
1899
1900                 //
1901                 // Indicate this node requires re-evaluation for the remaining reasons
1902                 //
1903
1904                 pObjectInfo->Expiration.QuadPart = 0;
1905
1906                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1907                               AFS_TRACE_LEVEL_VERBOSE,
1908                               "AFSInvalidateCache Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
1909                               pObjectInfo->FileId.Cell,
1910                               pObjectInfo->FileId.Volume,
1911                               pObjectInfo->FileId.Vnode,
1912                               pObjectInfo->FileId.Unique);
1913
1914                 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
1915
1916                 if( InvalidateCB->Reason == AFS_INVALIDATE_FLUSHED ||
1917                     InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
1918                 {
1919                     pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
1920
1921                     if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE)
1922                     {
1923
1924                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1925                                       AFS_TRACE_LEVEL_VERBOSE,
1926                                       "AFSInvalidateCache Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
1927                                       pObjectInfo->FileId.Cell,
1928                                       pObjectInfo->FileId.Volume,
1929                                       pObjectInfo->FileId.Vnode,
1930                                       pObjectInfo->FileId.Unique);
1931
1932                         SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
1933                     }
1934                 }
1935
1936                 break;
1937             }
1938         }
1939
1940 try_exit:
1941
1942         if( pObjectInfo != NULL)
1943         {
1944
1945             InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
1946
1947             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1948                           AFS_TRACE_LEVEL_VERBOSE,
1949                           "AFSInvalidateCache Decrement count on object %08lX Cnt %d\n",
1950                           pObjectInfo,
1951                           pObjectInfo->ObjectReferenceCount);
1952         }
1953     }
1954
1955     return ntStatus;
1956 }
1957
1958 BOOLEAN
1959 AFSIsChildOfParent( IN AFSFcb *Dcb,
1960                     IN AFSFcb *Fcb)
1961 {
1962
1963     BOOLEAN bIsChild = FALSE;
1964     AFSFcb *pCurrentFcb = Fcb;
1965
1966     while( pCurrentFcb != NULL)
1967     {
1968
1969         if( pCurrentFcb->ObjectInformation->ParentObjectInformation == Dcb->ObjectInformation)
1970         {
1971
1972             bIsChild = TRUE;
1973
1974             break;
1975         }
1976
1977         pCurrentFcb = pCurrentFcb->ObjectInformation->ParentObjectInformation->Fcb;
1978     }
1979
1980     return bIsChild;
1981 }
1982
1983 inline
1984 ULONGLONG
1985 AFSCreateHighIndex( IN AFSFileID *FileID)
1986 {
1987
1988     ULONGLONG ullIndex = 0;
1989
1990     ullIndex = (((ULONGLONG)FileID->Cell << 32) | FileID->Volume);
1991
1992     return ullIndex;
1993 }
1994
1995 inline
1996 ULONGLONG
1997 AFSCreateLowIndex( IN AFSFileID *FileID)
1998 {
1999
2000     ULONGLONG ullIndex = 0;
2001
2002     ullIndex = (((ULONGLONG)FileID->Vnode << 32) | FileID->Unique);
2003
2004     return ullIndex;
2005 }
2006
2007 BOOLEAN
2008 AFSCheckAccess( IN ACCESS_MASK DesiredAccess,
2009                 IN ACCESS_MASK GrantedAccess,
2010                 IN BOOLEAN DirectoryEntry)
2011 {
2012
2013     BOOLEAN bAccessGranted = TRUE;
2014
2015     //
2016     // Check if we are asking for read/write and granted only read only
2017     // NOTE: There will be more checks here
2018     //
2019
2020     if( !AFSCheckForReadOnlyAccess( DesiredAccess,
2021                                     DirectoryEntry) &&
2022         AFSCheckForReadOnlyAccess( GrantedAccess,
2023                                    DirectoryEntry))
2024     {
2025
2026         bAccessGranted = FALSE;
2027     }
2028
2029     return bAccessGranted;
2030 }
2031
2032 NTSTATUS
2033 AFSGetDriverStatus( IN AFSDriverStatusRespCB *DriverStatus)
2034 {
2035
2036     NTSTATUS         ntStatus = STATUS_SUCCESS;
2037     AFSDeviceExt    *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2038
2039     //
2040     // Start with read
2041     //
2042
2043     DriverStatus->Status = AFS_DRIVER_STATUS_READY;
2044
2045     if( AFSGlobalRoot == NULL)
2046     {
2047
2048         //
2049         // We are not ready
2050         //
2051
2052         DriverStatus->Status = AFS_DRIVER_STATUS_NOT_READY;
2053     }
2054
2055     if( pControlDevExt->Specific.Control.CommServiceCB.IrpPoolControlFlag != POOL_ACTIVE)
2056     {
2057
2058         //
2059         // No service yet
2060         //
2061
2062         DriverStatus->Status = AFS_DRIVER_STATUS_NO_SERVICE;
2063     }
2064
2065     return ntStatus;
2066 }
2067
2068 NTSTATUS
2069 AFSSubstituteSysName( IN UNICODE_STRING *ComponentName,
2070                       IN UNICODE_STRING *SubstituteName,
2071                       IN ULONG StringIndex)
2072 {
2073
2074     NTSTATUS ntStatus = STATUS_SUCCESS;
2075     AFSDeviceExt    *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2076     AFSSysNameCB    *pSysName = NULL;
2077     ERESOURCE       *pSysNameLock = NULL;
2078     ULONG            ulIndex = 1;
2079     USHORT           usIndex = 0;
2080     UNICODE_STRING   uniSysName;
2081
2082     __Enter
2083     {
2084
2085 #if defined(_WIN64)
2086
2087         if( IoIs32bitProcess( NULL))
2088         {
2089
2090             pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
2091
2092             pSysName = pControlDevExt->Specific.Control.SysName32ListHead;
2093         }
2094         else
2095         {
2096
2097             pSysNameLock = &pControlDevExt->Specific.Control.SysName64ListLock;
2098
2099             pSysName = pControlDevExt->Specific.Control.SysName64ListHead;
2100         }
2101 #else
2102
2103         pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
2104
2105         pSysName = pControlDevExt->Specific.Control.SysName32ListHead;
2106
2107 #endif
2108
2109         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2110                       AFS_TRACE_LEVEL_VERBOSE,
2111                       "AFSSubstituteSysName Acquiring SysName lock %08lX SHARED %08lX\n",
2112                       pSysNameLock,
2113                       PsGetCurrentThread());
2114
2115         AFSAcquireShared( pSysNameLock,
2116                           TRUE);
2117
2118         //
2119         // Find where we are in the list
2120         //
2121
2122         while( pSysName != NULL &&
2123             ulIndex < StringIndex)
2124         {
2125
2126             pSysName = pSysName->fLink;
2127
2128             ulIndex++;
2129         }
2130
2131         if( pSysName == NULL)
2132         {
2133
2134             try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
2135         }
2136
2137         RtlInitUnicodeString( &uniSysName,
2138                               L"@SYS");
2139         //
2140         // If it is a full component of @SYS then just substitue the
2141         // name in
2142         //
2143
2144         if( RtlCompareUnicodeString( &uniSysName,
2145                                      ComponentName,
2146                                      TRUE) == 0)
2147         {
2148
2149             SubstituteName->Length = pSysName->SysName.Length;
2150             SubstituteName->MaximumLength = SubstituteName->Length;
2151
2152             SubstituteName->Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2153                                                                         SubstituteName->Length,
2154                                                                         AFS_SUBST_BUFFER_TAG);
2155
2156             if( SubstituteName->Buffer == NULL)
2157             {
2158
2159                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2160             }
2161
2162             RtlCopyMemory( SubstituteName->Buffer,
2163                            pSysName->SysName.Buffer,
2164                            pSysName->SysName.Length);
2165         }
2166         else
2167         {
2168
2169             usIndex = 0;
2170
2171             while( ComponentName->Buffer[ usIndex] != L'@')
2172             {
2173
2174                 usIndex++;
2175             }
2176
2177             SubstituteName->Length = (usIndex * sizeof( WCHAR)) + pSysName->SysName.Length;
2178             SubstituteName->MaximumLength = SubstituteName->Length;
2179
2180             SubstituteName->Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2181                                                                         SubstituteName->Length,
2182                                                                         AFS_SUBST_BUFFER_TAG);
2183
2184             if( SubstituteName->Buffer == NULL)
2185             {
2186
2187                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2188             }
2189
2190             RtlCopyMemory( SubstituteName->Buffer,
2191                            ComponentName->Buffer,
2192                            usIndex * sizeof( WCHAR));
2193
2194             RtlCopyMemory( &SubstituteName->Buffer[ usIndex],
2195                            pSysName->SysName.Buffer,
2196                            pSysName->SysName.Length);
2197         }
2198
2199 try_exit:
2200
2201         AFSReleaseResource( pSysNameLock);
2202     }
2203
2204     return ntStatus;
2205 }
2206
2207 NTSTATUS
2208 AFSSubstituteNameInPath( IN OUT UNICODE_STRING *FullPathName,
2209                          IN OUT UNICODE_STRING *ComponentName,
2210                          IN UNICODE_STRING *SubstituteName,
2211                          IN OUT UNICODE_STRING *RemainingPath,
2212                          IN BOOLEAN FreePathName)
2213 {
2214
2215     NTSTATUS ntStatus = STATUS_SUCCESS;
2216     UNICODE_STRING uniPathName;
2217     USHORT usPrefixNameLen = 0;
2218     SHORT  sNameLenDelta = 0;
2219
2220     __Enter
2221     {
2222
2223         //
2224         // If the passed in name can handle the additional length
2225         // then just moves things around
2226         //
2227
2228         sNameLenDelta = SubstituteName->Length - ComponentName->Length;
2229
2230         usPrefixNameLen = (USHORT)(ComponentName->Buffer - FullPathName->Buffer);
2231
2232         if( FullPathName->MaximumLength > FullPathName->Length + sNameLenDelta)
2233         {
2234
2235             if( FullPathName->Length > usPrefixNameLen + ComponentName->Length)
2236             {
2237
2238                 RtlMoveMemory( &FullPathName->Buffer[ ((usPrefixNameLen*sizeof( WCHAR) + SubstituteName->Length)/sizeof( WCHAR))],
2239                                &FullPathName->Buffer[ ((usPrefixNameLen*sizeof( WCHAR) + ComponentName->Length)/sizeof( WCHAR))],
2240                                FullPathName->Length - usPrefixNameLen*sizeof( WCHAR) - ComponentName->Length);
2241             }
2242
2243             RtlCopyMemory( &FullPathName->Buffer[ usPrefixNameLen],
2244                            SubstituteName->Buffer,
2245                            SubstituteName->Length);
2246
2247             FullPathName->Length += sNameLenDelta;
2248
2249             ComponentName->Length += sNameLenDelta;
2250
2251             ComponentName->MaximumLength = ComponentName->Length;
2252
2253             if ( RemainingPath->Buffer)
2254             {
2255
2256                 RemainingPath->Buffer += sNameLenDelta/sizeof( WCHAR);
2257             }
2258
2259             try_return( ntStatus);
2260         }
2261
2262         //
2263         // Need to re-allocate the buffer
2264         //
2265
2266         uniPathName.Length = FullPathName->Length -
2267                                          ComponentName->Length +
2268                                          SubstituteName->Length;
2269
2270         uniPathName.MaximumLength = FullPathName->MaximumLength + PAGE_SIZE;
2271
2272         uniPathName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2273                                                                 uniPathName.MaximumLength,
2274                                                                 AFS_NAME_BUFFER_FOUR_TAG);
2275
2276         if( uniPathName.Buffer == NULL)
2277         {
2278
2279             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2280         }
2281
2282         usPrefixNameLen = (USHORT)(ComponentName->Buffer - FullPathName->Buffer);
2283
2284         usPrefixNameLen *= sizeof( WCHAR);
2285
2286         RtlZeroMemory( uniPathName.Buffer,
2287                        uniPathName.MaximumLength);
2288
2289         RtlCopyMemory( uniPathName.Buffer,
2290                        FullPathName->Buffer,
2291                        usPrefixNameLen);
2292
2293         RtlCopyMemory( &uniPathName.Buffer[ (usPrefixNameLen/sizeof( WCHAR))],
2294                        SubstituteName->Buffer,
2295                        SubstituteName->Length);
2296
2297         if( FullPathName->Length > usPrefixNameLen + ComponentName->Length)
2298         {
2299
2300             RtlCopyMemory( &uniPathName.Buffer[ (usPrefixNameLen + SubstituteName->Length)/sizeof( WCHAR)],
2301                            &FullPathName->Buffer[ (usPrefixNameLen + ComponentName->Length)/sizeof( WCHAR)],
2302                            FullPathName->Length - usPrefixNameLen - ComponentName->Length);
2303         }
2304
2305         ComponentName->Buffer = uniPathName.Buffer + (ComponentName->Buffer - FullPathName->Buffer);
2306
2307         ComponentName->Length += sNameLenDelta;
2308
2309         ComponentName->MaximumLength = ComponentName->Length;
2310
2311         if ( RemainingPath->Buffer)
2312         {
2313
2314             RemainingPath->Buffer = uniPathName.Buffer
2315                 + (RemainingPath->Buffer - FullPathName->Buffer)
2316                 + sNameLenDelta/sizeof( WCHAR);
2317         }
2318
2319         if( FreePathName)
2320         {
2321             AFSExFreePool( FullPathName->Buffer);
2322         }
2323
2324         *FullPathName = uniPathName;
2325
2326 try_exit:
2327
2328         NOTHING;
2329     }
2330
2331     return ntStatus;
2332 }
2333
2334 NTSTATUS
2335 AFSInvalidateVolume( IN AFSVolumeCB *VolumeCB,
2336                      IN ULONG Reason)
2337 {
2338
2339     NTSTATUS ntStatus = STATUS_SUCCESS;
2340     AFSFcb *pFcb = NULL;
2341     AFSObjectInfoCB *pCurrentObject = NULL;
2342     ULONG ulFilter = 0;
2343
2344     __Enter
2345     {
2346
2347         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2348                       AFS_TRACE_LEVEL_VERBOSE,
2349                       "AFSInvalidateVolume Invalidate volume fid %08lX-%08lX-%08lX-%08lX Reason %08lX\n",
2350                       VolumeCB->ObjectInformation.FileId.Cell,
2351                       VolumeCB->ObjectInformation.FileId.Volume,
2352                       VolumeCB->ObjectInformation.FileId.Vnode,
2353                       VolumeCB->ObjectInformation.FileId.Unique,
2354                       Reason);
2355
2356         //
2357         // Depending on the reason for invalidation then perform work on the node
2358         //
2359
2360         switch( Reason)
2361         {
2362
2363             case AFS_INVALIDATE_DELETED:
2364             {
2365
2366                 //
2367                 // Mark this volume as invalid
2368                 //
2369
2370                 VolumeCB->ObjectInformation.Expiration.QuadPart = 0;
2371
2372                 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
2373
2374                 SetFlag( VolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE);
2375
2376                 AFSFsRtlNotifyFullReportChange( &VolumeCB->ObjectInformation,
2377                                                 NULL,
2378                                                 FILE_NOTIFY_CHANGE_DIR_NAME,
2379                                                 FILE_ACTION_REMOVED);
2380
2381                 AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
2382                                   TRUE);
2383
2384                 pCurrentObject = VolumeCB->ObjectInfoListHead;
2385
2386                 while( pCurrentObject != NULL)
2387                 {
2388
2389                     if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY)
2390                     {
2391                         ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2392                     }
2393                     else
2394                     {
2395                         ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2396                     }
2397
2398                     AFSFsRtlNotifyFullReportChange( pCurrentObject,
2399                                                     NULL,
2400                                                     ulFilter,
2401                                                     FILE_ACTION_REMOVED);
2402
2403                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
2404
2405                     pFcb = pCurrentObject->Fcb;
2406
2407                     if( pFcb != NULL &&
2408                         pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2409                     {
2410
2411
2412                         //
2413                         // Clear out the extents
2414                         // And get rid of them (note this involves waiting
2415                         // for any writes or reads to the cache to complete)
2416                         //
2417
2418                         (VOID) AFSTearDownFcbExtents( pFcb);
2419                     }
2420
2421                     pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
2422                 }
2423
2424                 AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
2425
2426                 break;
2427             }
2428
2429             default:
2430             {
2431
2432                 //
2433                 // Indicate this node requires re-evaluation for the remaining reasons
2434                 //
2435
2436                 VolumeCB->ObjectInformation.Expiration.QuadPart = 0;
2437
2438                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2439                               AFS_TRACE_LEVEL_VERBOSE,
2440                               "AFSInvalidateVolume Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
2441                               VolumeCB->ObjectInformation.FileId.Cell,
2442                               VolumeCB->ObjectInformation.FileId.Volume,
2443                               VolumeCB->ObjectInformation.FileId.Vnode,
2444                               VolumeCB->ObjectInformation.FileId.Unique);
2445
2446                 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY);
2447
2448                 if( Reason == AFS_INVALIDATE_FLUSHED ||
2449                     Reason == AFS_INVALIDATE_DATA_VERSION)
2450                 {
2451
2452                     VolumeCB->ObjectInformation.DataVersion.QuadPart = (ULONGLONG)-1;
2453                 }
2454
2455                 //
2456                 // Notify anyone that cares
2457                 //
2458
2459                 ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2460
2461                 if( Reason == AFS_INVALIDATE_CREDS)
2462                 {
2463                     ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
2464                 }
2465
2466                 if( Reason == AFS_INVALIDATE_DATA_VERSION)
2467                 {
2468                     ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
2469                 }
2470                 else
2471                 {
2472                     ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
2473                 }
2474
2475                 AFSFsRtlNotifyFullReportChange( &VolumeCB->ObjectInformation,
2476                                                 NULL,
2477                                                 ulFilter,
2478                                                 FILE_ACTION_MODIFIED);
2479
2480                 //
2481                 // Volume invalidations require all objects in the volume be re-verified
2482                 //
2483
2484                 AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
2485                                   TRUE);
2486
2487                 pCurrentObject = VolumeCB->ObjectInfoListHead;
2488
2489                 while( pCurrentObject != NULL)
2490                 {
2491
2492                     pCurrentObject->Expiration.QuadPart = 0;
2493
2494                     pCurrentObject->TargetFileId.Vnode = 0;
2495
2496                     pCurrentObject->TargetFileId.Unique = 0;
2497
2498                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2499                                   AFS_TRACE_LEVEL_VERBOSE,
2500                                   "AFSInvalidateVolume Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
2501                                   pCurrentObject->FileId.Cell,
2502                                   pCurrentObject->FileId.Volume,
2503                                   pCurrentObject->FileId.Vnode,
2504                                   pCurrentObject->FileId.Unique);
2505
2506                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
2507
2508                     if( Reason == AFS_INVALIDATE_FLUSHED ||
2509                         Reason == AFS_INVALIDATE_DATA_VERSION)
2510                     {
2511
2512                         pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
2513
2514                         if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
2515                         {
2516
2517                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2518                                           AFS_TRACE_LEVEL_VERBOSE,
2519                                           "AFSInvalidateVolume Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
2520                                           pCurrentObject->FileId.Cell,
2521                                           pCurrentObject->FileId.Volume,
2522                                           pCurrentObject->FileId.Vnode,
2523                                           pCurrentObject->FileId.Unique);
2524
2525                             SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
2526                         }
2527                     }
2528
2529                     if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY)
2530                     {
2531                         ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2532                     }
2533                     else
2534                     {
2535                         ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2536                     }
2537
2538                     if( Reason == AFS_INVALIDATE_CREDS)
2539                     {
2540                         ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
2541                     }
2542
2543                     if( Reason == AFS_INVALIDATE_DATA_VERSION)
2544                     {
2545                         ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
2546                     }
2547                     else
2548                     {
2549                         ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
2550                     }
2551
2552                     AFSFsRtlNotifyFullReportChange( pCurrentObject,
2553                                                     NULL,
2554                                                     ulFilter,
2555                                                     FILE_ACTION_MODIFIED);
2556
2557                     pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
2558                 }
2559
2560                 AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
2561
2562                 break;
2563             }
2564         }
2565     }
2566
2567     return ntStatus;
2568 }
2569
2570 NTSTATUS
2571 AFSVerifyEntry( IN GUID *AuthGroup,
2572                 IN AFSDirectoryCB *DirEntry)
2573 {
2574
2575     NTSTATUS ntStatus = STATUS_SUCCESS;
2576     AFSDirEnumEntry *pDirEnumEntry = NULL;
2577     AFSObjectInfoCB *pObjectInfo = DirEntry->ObjectInformation;
2578     IO_STATUS_BLOCK stIoStatus;
2579
2580     __Enter
2581     {
2582
2583         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2584                       AFS_TRACE_LEVEL_VERBOSE_2,
2585                       "AFSVerifyEntry Verifying entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2586                       &DirEntry->NameInformation.FileName,
2587                       pObjectInfo->FileId.Cell,
2588                       pObjectInfo->FileId.Volume,
2589                       pObjectInfo->FileId.Vnode,
2590                       pObjectInfo->FileId.Unique);
2591
2592         ntStatus = AFSEvaluateTargetByID( pObjectInfo,
2593                                           AuthGroup,
2594                                           FALSE,
2595                                           &pDirEnumEntry);
2596
2597         if( !NT_SUCCESS( ntStatus))
2598         {
2599
2600             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2601                           AFS_TRACE_LEVEL_ERROR,
2602                           "AFSValidateEntry Evaluate Target failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
2603                           &DirEntry->NameInformation.FileName,
2604                           pObjectInfo->FileId.Cell,
2605                           pObjectInfo->FileId.Volume,
2606                           pObjectInfo->FileId.Vnode,
2607                           pObjectInfo->FileId.Unique,
2608                           ntStatus);
2609
2610             try_return( ntStatus);
2611         }
2612
2613         //
2614         // Check the data version of the file
2615         //
2616
2617         if( pObjectInfo->DataVersion.QuadPart == pDirEnumEntry->DataVersion.QuadPart &&
2618             !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
2619         {
2620
2621             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2622                           AFS_TRACE_LEVEL_VERBOSE,
2623                           "AFSVerifyEntry No DV change %I64X for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2624                           pObjectInfo->DataVersion.QuadPart,
2625                           &DirEntry->NameInformation.FileName,
2626                           pObjectInfo->FileId.Cell,
2627                           pObjectInfo->FileId.Volume,
2628                           pObjectInfo->FileId.Vnode,
2629                           pObjectInfo->FileId.Unique);
2630
2631             //
2632             // We are ok, just get out
2633             //
2634
2635             ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2636
2637             try_return( ntStatus = STATUS_SUCCESS);
2638         }
2639
2640         //
2641         // New data version so we will need to process the node based on the type
2642         //
2643
2644         switch( pDirEnumEntry->FileType)
2645         {
2646
2647             case AFS_FILE_TYPE_MOUNTPOINT:
2648             {
2649
2650                 //
2651                 // For a mount point we need to ensure the target is the same
2652                 //
2653
2654                 if( !AFSIsEqualFID( &pObjectInfo->TargetFileId,
2655                                     &pDirEnumEntry->TargetFileId))
2656                 {
2657
2658                 }
2659
2660                 //
2661                 // Update the metadata for the entry
2662                 //
2663
2664                 ntStatus = AFSUpdateMetaData( DirEntry,
2665                                               pDirEnumEntry);
2666
2667                 if( NT_SUCCESS( ntStatus))
2668                 {
2669
2670                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2671                 }
2672
2673                 break;
2674             }
2675
2676             case AFS_FILE_TYPE_SYMLINK:
2677             {
2678
2679                 ASSERT( pDirEnumEntry->TargetNameLength > 0);
2680
2681                 //
2682                 // Update the metadata for the entry
2683                 //
2684
2685                 ntStatus = AFSUpdateMetaData( DirEntry,
2686                                               pDirEnumEntry);
2687
2688                 if( NT_SUCCESS( ntStatus))
2689                 {
2690
2691                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2692                 }
2693
2694                 break;
2695             }
2696
2697             case AFS_FILE_TYPE_FILE:
2698             {
2699                 FILE_OBJECT * pCCFileObject = NULL;
2700                 BOOLEAN bPurgeExtents = FALSE;
2701
2702                 if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
2703                 {
2704                     bPurgeExtents = TRUE;
2705
2706                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2707                                   AFS_TRACE_LEVEL_VERBOSE,
2708                                   "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2709                                   &DirEntry->NameInformation.FileName,
2710                                   pObjectInfo->FileId.Cell,
2711                                   pObjectInfo->FileId.Volume,
2712                                   pObjectInfo->FileId.Vnode,
2713                                   pObjectInfo->FileId.Unique);
2714
2715                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
2716                 }
2717
2718                 //
2719                 // Update the metadata for the entry
2720                 //
2721
2722                 ntStatus = AFSUpdateMetaData( DirEntry,
2723                                               pDirEnumEntry);
2724
2725                 if( !NT_SUCCESS( ntStatus))
2726                 {
2727
2728                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2729                                   AFS_TRACE_LEVEL_ERROR,
2730                                   "AFSInvalidateCache Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
2731                                   &DirEntry->NameInformation.FileName,
2732                                   pObjectInfo->FileId.Cell,
2733                                   pObjectInfo->FileId.Volume,
2734                                   pObjectInfo->FileId.Vnode,
2735                                   pObjectInfo->FileId.Unique,
2736                                   ntStatus);
2737
2738                     break;
2739                 }
2740
2741                 if( pObjectInfo->Fcb != NULL)
2742                 {
2743
2744                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2745                                   AFS_TRACE_LEVEL_VERBOSE,
2746                                   "AFSVerifyEntry Flush/purge entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2747                                   &DirEntry->NameInformation.FileName,
2748                                   pObjectInfo->FileId.Cell,
2749                                   pObjectInfo->FileId.Volume,
2750                                   pObjectInfo->FileId.Vnode,
2751                                   pObjectInfo->FileId.Unique);
2752
2753                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
2754                                     TRUE);
2755
2756                     __try
2757                     {
2758
2759                         CcFlushCache( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2760                                       NULL,
2761                                       0,
2762                                       &stIoStatus);
2763
2764                         if( !NT_SUCCESS( stIoStatus.Status))
2765                         {
2766
2767                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2768                                           AFS_TRACE_LEVEL_ERROR,
2769                                           "AFSVerifyEntry CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
2770                                           &DirEntry->NameInformation.FileName,
2771                                           pObjectInfo->FileId.Cell,
2772                                           pObjectInfo->FileId.Volume,
2773                                           pObjectInfo->FileId.Vnode,
2774                                           pObjectInfo->FileId.Unique,
2775                                           stIoStatus.Status,
2776                                           stIoStatus.Information);
2777
2778                             ntStatus = stIoStatus.Status;
2779                         }
2780
2781                         if ( bPurgeExtents)
2782                         {
2783
2784                             CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2785                                                  NULL,
2786                                                  0,
2787                                                  FALSE);
2788                         }
2789                     }
2790                     __except( EXCEPTION_EXECUTE_HANDLER)
2791                     {
2792                         ntStatus = GetExceptionCode();
2793
2794                         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2795                                       AFS_TRACE_LEVEL_ERROR,
2796                                       "AFSVerifyEntry CcFlushCache or CcPurgeCacheSection Exception %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
2797                                       &DirEntry->NameInformation.FileName,
2798                                       pObjectInfo->FileId.Cell,
2799                                       pObjectInfo->FileId.Volume,
2800                                       pObjectInfo->FileId.Vnode,
2801                                       pObjectInfo->FileId.Unique,
2802                                       ntStatus);
2803                     }
2804
2805                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
2806
2807                     if ( bPurgeExtents)
2808                     {
2809                         AFSFlushExtents( pObjectInfo->Fcb);
2810                     }
2811
2812                     //
2813                     // Reacquire the Fcb to purge the cache
2814                     //
2815
2816                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2817                                   AFS_TRACE_LEVEL_VERBOSE,
2818                                   "AFSVerifyEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
2819                                   &pObjectInfo->Fcb->NPFcb->Resource,
2820                                   PsGetCurrentThread());
2821
2822                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
2823                                     TRUE);
2824
2825                     //
2826                     // Update file sizes
2827                     //
2828
2829                     pObjectInfo->Fcb->Header.AllocationSize.QuadPart  = pObjectInfo->AllocationSize.QuadPart;
2830                     pObjectInfo->Fcb->Header.FileSize.QuadPart        = pObjectInfo->EndOfFile.QuadPart;
2831                     pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
2832
2833                     pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
2834
2835                     if ( pCCFileObject != NULL)
2836                     {
2837                         CcSetFileSizes( pCCFileObject,
2838                                         (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
2839                     }
2840
2841                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
2842                 }
2843                 else
2844                 {
2845                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2846                                   AFS_TRACE_LEVEL_WARNING,
2847                                   "AFSValidateEntry Fcb NULL %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2848                                   &DirEntry->NameInformation.FileName,
2849                                   pObjectInfo->FileId.Cell,
2850                                   pObjectInfo->FileId.Volume,
2851                                   pObjectInfo->FileId.Vnode,
2852                                   pObjectInfo->FileId.Unique);
2853                 }
2854
2855                 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2856
2857                 break;
2858             }
2859
2860             case AFS_FILE_TYPE_DIRECTORY:
2861             {
2862
2863                 AFSFcb *pCurrentFcb = NULL;
2864                 AFSDirectoryCB *pCurrentDirEntry = NULL;
2865
2866                 //
2867                 // For a directory or root entry flush the content of
2868                 // the directory enumeration.
2869                 //
2870
2871                 if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
2872                 {
2873
2874                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2875                                   AFS_TRACE_LEVEL_VERBOSE_2,
2876                                   "AFSVerifyEntry Validating directory content for entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2877                                   &DirEntry->NameInformation.FileName,
2878                                   pObjectInfo->FileId.Cell,
2879                                   pObjectInfo->FileId.Volume,
2880                                   pObjectInfo->FileId.Vnode,
2881                                   pObjectInfo->FileId.Unique);
2882
2883                     AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2884                                     TRUE);
2885
2886                     AFSValidateDirectoryCache( pObjectInfo,
2887                                                AuthGroup);
2888
2889                     AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2890                 }
2891
2892                 //
2893                 // Update the metadata for the entry
2894                 //
2895
2896                 ntStatus = AFSUpdateMetaData( DirEntry,
2897                                               pDirEnumEntry);
2898
2899                 if( NT_SUCCESS( ntStatus))
2900                 {
2901
2902                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2903                 }
2904
2905                 break;
2906             }
2907
2908             case AFS_FILE_TYPE_DFSLINK:
2909             {
2910
2911                 UNICODE_STRING uniTargetName;
2912
2913                 //
2914                 // For a DFS link need to check the target name has not changed
2915                 //
2916
2917                 uniTargetName.Length = (USHORT)pDirEnumEntry->TargetNameLength;
2918
2919                 uniTargetName.MaximumLength = uniTargetName.Length;
2920
2921                 uniTargetName.Buffer = (WCHAR *)((char *)pDirEnumEntry + pDirEnumEntry->TargetNameOffset);
2922
2923                 AFSAcquireExcl( &DirEntry->NonPaged->Lock,
2924                                 TRUE);
2925
2926                 if( DirEntry->NameInformation.TargetName.Length == 0 ||
2927                     RtlCompareUnicodeString( &uniTargetName,
2928                                              &DirEntry->NameInformation.TargetName,
2929                                              TRUE) != 0)
2930                 {
2931
2932                     //
2933                     // Update the target name
2934                     //
2935
2936                     ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
2937                                                     &DirEntry->Flags,
2938                                                     uniTargetName.Buffer,
2939                                                     uniTargetName.Length);
2940
2941                     if( !NT_SUCCESS( ntStatus))
2942                     {
2943
2944                         AFSReleaseResource( &DirEntry->NonPaged->Lock);
2945
2946                         break;
2947                     }
2948                 }
2949
2950                 AFSReleaseResource( &DirEntry->NonPaged->Lock);
2951
2952                 //
2953                 // Update the metadata for the entry
2954                 //
2955
2956                 ntStatus = AFSUpdateMetaData( DirEntry,
2957                                               pDirEnumEntry);
2958
2959                 if( NT_SUCCESS( ntStatus))
2960                 {
2961
2962                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2963                 }
2964
2965                 break;
2966             }
2967
2968             default:
2969
2970                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2971                               AFS_TRACE_LEVEL_WARNING,
2972                               "AFSVerifyEntry Attempt to verify node of type %d\n",
2973                               pObjectInfo->FileType);
2974
2975                 break;
2976         }
2977
2978  try_exit:
2979
2980         if( pDirEnumEntry != NULL)
2981         {
2982
2983             AFSExFreePool( pDirEnumEntry);
2984         }
2985     }
2986
2987     return ntStatus;
2988 }
2989
2990 NTSTATUS
2991 AFSSetVolumeState( IN AFSVolumeStatusCB *VolumeStatus)
2992 {
2993
2994     NTSTATUS ntStatus = STATUS_SUCCESS;
2995     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
2996     ULONGLONG   ullIndex = 0;
2997     AFSVolumeCB *pVolumeCB = NULL;
2998     AFSFcb *pFcb = NULL;
2999     AFSObjectInfoCB *pCurrentObject = NULL;
3000
3001     __Enter
3002     {
3003
3004         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3005                       AFS_TRACE_LEVEL_VERBOSE,
3006                       "AFSSetVolumeState Marking volume state %d Volume Cell %08lX Volume %08lX\n",
3007                       VolumeStatus->Online,
3008                       VolumeStatus->FileID.Cell,
3009                       VolumeStatus->FileID.Volume);
3010
3011         //
3012         // Need to locate the Fcb for the directory to purge
3013         //
3014
3015         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3016                       AFS_TRACE_LEVEL_VERBOSE,
3017                       "AFSSetVolumeState Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
3018                       &pDevExt->Specific.RDR.VolumeTreeLock,
3019                       PsGetCurrentThread());
3020
3021         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
3022
3023         //
3024         // Locate the volume node
3025         //
3026
3027         ullIndex = AFSCreateHighIndex( &VolumeStatus->FileID);
3028
3029         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
3030                                        ullIndex,
3031                                        (AFSBTreeEntry **)&pVolumeCB);
3032
3033         if( pVolumeCB != NULL)
3034         {
3035
3036             InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
3037
3038             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
3039
3040             //
3041             // Set the volume state accordingly
3042             //
3043
3044             if( VolumeStatus->Online)
3045             {
3046
3047                 InterlockedAnd( (LONG *)&(pVolumeCB->Flags), ~AFS_VOLUME_FLAGS_OFFLINE);
3048             }
3049             else
3050             {
3051
3052                 InterlockedOr( (LONG *)&(pVolumeCB->Flags), AFS_VOLUME_FLAGS_OFFLINE);
3053             }
3054
3055             AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
3056                               TRUE);
3057
3058             pCurrentObject = pVolumeCB->ObjectInfoListHead;;
3059
3060             while( pCurrentObject != NULL)
3061             {
3062
3063                 if( VolumeStatus->Online)
3064                 {
3065
3066                     ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
3067
3068                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
3069
3070                     pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
3071                 }
3072                 else
3073                 {
3074
3075                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
3076                 }
3077
3078                 pFcb = pCurrentObject->Fcb;
3079
3080                 if( pFcb != NULL &&
3081                     !(VolumeStatus->Online) &&
3082                     pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
3083                 {
3084
3085                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3086                                   AFS_TRACE_LEVEL_ERROR,
3087                                   "AFSSetVolumeState Marking volume offline and canceling extents Volume Cell %08lX Volume %08lX\n",
3088                                   VolumeStatus->FileID.Cell,
3089                                   VolumeStatus->FileID.Volume);
3090
3091                     //
3092                     // Clear out the extents
3093                     //
3094
3095                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3096                                   AFS_TRACE_LEVEL_VERBOSE,
3097                                   "AFSSetVolumeState Acquiring Fcb extents lock %08lX EXCL %08lX\n",
3098                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
3099                                   PsGetCurrentThread());
3100
3101                     AFSAcquireExcl( &pFcb->NPFcb->Specific.File.ExtentsResource,
3102                                     TRUE);
3103
3104                     pFcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_CANCELLED;
3105
3106                     KeSetEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete,
3107                                 0,
3108                                 FALSE);
3109
3110                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3111                                   AFS_TRACE_LEVEL_VERBOSE,
3112                                   "AFSSetVolumeState Releasing Fcb extents lock %08lX EXCL %08lX\n",
3113                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
3114                                   PsGetCurrentThread());
3115
3116                     AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource);
3117
3118                     //
3119                     // And get rid of them (note this involves waiting
3120                     // for any writes or reads to the cache to complete)
3121                     //
3122
3123                     (VOID) AFSTearDownFcbExtents( pFcb);
3124                 }
3125
3126                 pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
3127             }
3128
3129             AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
3130
3131             InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
3132         }
3133         else
3134         {
3135
3136             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
3137         }
3138     }
3139
3140     return ntStatus;
3141 }
3142
3143 NTSTATUS
3144 AFSSetNetworkState( IN AFSNetworkStatusCB *NetworkStatus)
3145 {
3146
3147     NTSTATUS ntStatus = STATUS_SUCCESS;
3148
3149     __Enter
3150     {
3151
3152         if( AFSGlobalRoot == NULL)
3153         {
3154
3155             try_return( ntStatus);
3156         }
3157
3158         AFSAcquireExcl( AFSGlobalRoot->VolumeLock,
3159                         TRUE);
3160
3161         //
3162         // Set the network state according to the information
3163         //
3164
3165         if( NetworkStatus->Online)
3166         {
3167
3168             ClearFlag( AFSGlobalRoot->Flags, AFS_VOLUME_FLAGS_OFFLINE);
3169         }
3170         else
3171         {
3172
3173             SetFlag( AFSGlobalRoot->Flags, AFS_VOLUME_FLAGS_OFFLINE);
3174         }
3175
3176         AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3177
3178 try_exit:
3179
3180         NOTHING;
3181     }
3182
3183     return ntStatus;
3184 }
3185
3186 NTSTATUS
3187 AFSValidateDirectoryCache( IN AFSObjectInfoCB *ObjectInfo,
3188                            IN GUID *AuthGroup)
3189 {
3190
3191     NTSTATUS ntStatus = STATUS_SUCCESS;
3192     BOOLEAN  bAcquiredLock = FALSE;
3193     AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
3194     AFSFcb *pFcb = NULL;
3195
3196     __Enter
3197     {
3198
3199         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3200                       AFS_TRACE_LEVEL_VERBOSE,
3201                       "AFSValidateDirectoryCache Validating content for FID %08lX-%08lX-%08lX-%08lX\n",
3202                       ObjectInfo->FileId.Cell,
3203                       ObjectInfo->FileId.Volume,
3204                       ObjectInfo->FileId.Vnode,
3205                       ObjectInfo->FileId.Unique);
3206
3207         if( !ExIsResourceAcquiredLite( ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock))
3208         {
3209
3210             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3211                           AFS_TRACE_LEVEL_VERBOSE,
3212                           "AFSValidateDirectoryCache Acquiring DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
3213                           ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
3214                           PsGetCurrentThread());
3215
3216             AFSAcquireExcl( ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
3217                             TRUE);
3218
3219             bAcquiredLock = TRUE;
3220         }
3221
3222         //
3223         // Check for inconsistency between DirectoryNodeList and DirectoryNodeCount
3224         //
3225
3226         if ( ObjectInfo->Specific.Directory.DirectoryNodeListHead == NULL &&
3227              ObjectInfo->Specific.Directory.DirectoryNodeCount > 0)
3228         {
3229
3230             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3231                           AFS_TRACE_LEVEL_ERROR,
3232                           "AFSValidateDirectoryCache Empty Node List but Non-Zero Node Count %08lX for dir FID %08lX-%08lX-%08lX-%08lX\n",
3233                           ObjectInfo->Specific.Directory.DirectoryNodeCount,
3234                           ObjectInfo->FileId.Cell,
3235                           ObjectInfo->FileId.Volume,
3236                           ObjectInfo->FileId.Vnode,
3237                           ObjectInfo->FileId.Unique);
3238         }
3239
3240         //
3241         // Reset the directory list information by clearing all valid entries
3242         //
3243
3244         pCurrentDirEntry = ObjectInfo->Specific.Directory.DirectoryNodeListHead;
3245
3246         while( pCurrentDirEntry != NULL)
3247         {
3248
3249             if( !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_FAKE))
3250             {
3251
3252                 ClearFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID);
3253
3254                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3255                               AFS_TRACE_LEVEL_VERBOSE,
3256                               "AFSValidateDirectoryCache Clear VALID flag on DE %p Reference count %08lX\n",
3257                               pCurrentDirEntry,
3258                               pCurrentDirEntry->OpenReferenceCount);
3259
3260             }
3261
3262             pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
3263         }
3264
3265         //
3266         // Reget the directory contents
3267         //
3268
3269         AFSVerifyDirectoryContent( ObjectInfo,
3270                                    AuthGroup);
3271
3272         //
3273         // Now start again and tear down any entries not valid
3274         //
3275
3276         pCurrentDirEntry = ObjectInfo->Specific.Directory.DirectoryNodeListHead;
3277
3278         while( pCurrentDirEntry != NULL)
3279         {
3280
3281             pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
3282
3283             if( BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID))
3284             {
3285
3286                 pCurrentDirEntry = pNextDirEntry;
3287
3288                 continue;
3289             }
3290
3291             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3292                           AFS_TRACE_LEVEL_VERBOSE,
3293                           "AFSValidateDirectoryCache Processing INVALID DE %p Reference count %08lX\n",
3294                           pCurrentDirEntry,
3295                           pCurrentDirEntry->OpenReferenceCount);
3296
3297             if( pCurrentDirEntry->OpenReferenceCount == 0)
3298             {
3299
3300                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3301                               AFS_TRACE_LEVEL_VERBOSE,
3302                               "AFSValidateDirectoryCache Deleting dir entry %wZ from parent FID %08lX-%08lX-%08lX-%08lX\n",
3303                               &pCurrentDirEntry->NameInformation.FileName,
3304                               ObjectInfo->FileId.Cell,
3305                               ObjectInfo->FileId.Volume,
3306                               ObjectInfo->FileId.Vnode,
3307                               ObjectInfo->FileId.Unique);
3308
3309                 AFSDeleteDirEntry( ObjectInfo,
3310                                    pCurrentDirEntry);
3311             }
3312             else
3313             {
3314
3315                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3316                               AFS_TRACE_LEVEL_VERBOSE,
3317                               "AFSValidateDirectoryCache Setting dir entry %p Name %wZ DELETED in parent FID %08lX-%08lX-%08lX-%08lX\n",
3318                               pCurrentDirEntry,
3319                               &pCurrentDirEntry->NameInformation.FileName,
3320                               ObjectInfo->FileId.Cell,
3321                               ObjectInfo->FileId.Volume,
3322                               ObjectInfo->FileId.Vnode,
3323                               ObjectInfo->FileId.Unique);
3324
3325                 SetFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3326
3327                 AFSRemoveNameEntry( ObjectInfo,
3328                                     pCurrentDirEntry);
3329             }
3330
3331             pCurrentDirEntry = pNextDirEntry;
3332         }
3333
3334 #if DBG
3335         if( !AFSValidateDirList( ObjectInfo))
3336         {
3337
3338             AFSPrint("AFSValidateDirectoryCache Invalid count ...\n");
3339         }
3340 #endif
3341
3342         if( bAcquiredLock)
3343         {
3344
3345             AFSReleaseResource( ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
3346         }
3347     }
3348
3349     return ntStatus;
3350 }
3351
3352 BOOLEAN
3353 AFSIsVolumeFID( IN AFSFileID *FileID)
3354 {
3355
3356     BOOLEAN bIsVolume = FALSE;
3357
3358     if( FileID->Vnode == 1 &&
3359         FileID->Unique == 1)
3360     {
3361
3362         bIsVolume = TRUE;
3363     }
3364
3365     return bIsVolume;
3366 }
3367
3368 BOOLEAN
3369 AFSIsFinalNode( IN AFSFcb *Fcb)
3370 {
3371
3372     BOOLEAN bIsFinalNode = FALSE;
3373
3374     if( Fcb->Header.NodeTypeCode == AFS_ROOT_FCB ||
3375         Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB ||
3376         Fcb->Header.NodeTypeCode == AFS_FILE_FCB ||
3377         Fcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
3378         Fcb->Header.NodeTypeCode == AFS_INVALID_FCB )
3379     {
3380
3381         bIsFinalNode = TRUE;
3382     }
3383     else
3384     {
3385
3386         ASSERT( Fcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
3387                 Fcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB);
3388     }
3389
3390     return bIsFinalNode;
3391 }
3392
3393 NTSTATUS
3394 AFSUpdateMetaData( IN AFSDirectoryCB *DirEntry,
3395                    IN AFSDirEnumEntry *DirEnumEntry)
3396 {
3397
3398     NTSTATUS ntStatus = STATUS_SUCCESS;
3399     UNICODE_STRING uniTargetName;
3400     AFSObjectInfoCB *pObjectInfo = DirEntry->ObjectInformation;
3401
3402     __Enter
3403     {
3404
3405         pObjectInfo->TargetFileId = DirEnumEntry->TargetFileId;
3406
3407         pObjectInfo->Expiration = DirEnumEntry->Expiration;
3408
3409         pObjectInfo->DataVersion = DirEnumEntry->DataVersion;
3410
3411         pObjectInfo->FileType = DirEnumEntry->FileType;
3412
3413         pObjectInfo->CreationTime = DirEnumEntry->CreationTime;
3414
3415         pObjectInfo->LastAccessTime = DirEnumEntry->LastAccessTime;
3416
3417         pObjectInfo->LastWriteTime = DirEnumEntry->LastWriteTime;
3418
3419         pObjectInfo->ChangeTime = DirEnumEntry->ChangeTime;
3420
3421         pObjectInfo->EndOfFile = DirEnumEntry->EndOfFile;
3422
3423         pObjectInfo->AllocationSize = DirEnumEntry->AllocationSize;
3424
3425         pObjectInfo->FileAttributes = DirEnumEntry->FileAttributes;
3426
3427         if( pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
3428             pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK ||
3429             pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK)
3430         {
3431
3432             pObjectInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
3433         }
3434
3435         pObjectInfo->EaSize = DirEnumEntry->EaSize;
3436
3437         pObjectInfo->Links = DirEnumEntry->Links;
3438
3439         if( DirEnumEntry->TargetNameLength > 0)
3440         {
3441
3442             //
3443             // Update the target name information if needed
3444             //
3445
3446             uniTargetName.Length = (USHORT)DirEnumEntry->TargetNameLength;
3447
3448             uniTargetName.MaximumLength = uniTargetName.Length;
3449
3450             uniTargetName.Buffer = (WCHAR *)((char *)DirEnumEntry + DirEnumEntry->TargetNameOffset);
3451
3452             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
3453                             TRUE);
3454
3455             if( DirEntry->NameInformation.TargetName.Length == 0 ||
3456                 RtlCompareUnicodeString( &uniTargetName,
3457                                          &DirEntry->NameInformation.TargetName,
3458                                          TRUE) != 0)
3459             {
3460
3461                 //
3462                 // Update the target name
3463                 //
3464
3465                 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
3466                                                 &DirEntry->Flags,
3467                                                 uniTargetName.Buffer,
3468                                                 uniTargetName.Length);
3469
3470                 if( !NT_SUCCESS( ntStatus))
3471                 {
3472
3473                     AFSReleaseResource( &DirEntry->NonPaged->Lock);
3474
3475                     try_return( ntStatus);
3476                 }
3477             }
3478
3479             AFSReleaseResource( &DirEntry->NonPaged->Lock);
3480         }
3481         else if( DirEntry->NameInformation.TargetName.Length > 0)
3482         {
3483
3484             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
3485                             TRUE);
3486
3487             if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER) &&
3488                 DirEntry->NameInformation.TargetName.Buffer != NULL)
3489             {
3490                 AFSExFreePool( DirEntry->NameInformation.TargetName.Buffer);
3491             }
3492
3493             ClearFlag( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER);
3494
3495             DirEntry->NameInformation.TargetName.Length = 0;
3496             DirEntry->NameInformation.TargetName.MaximumLength = 0;
3497             DirEntry->NameInformation.TargetName.Buffer = NULL;
3498
3499             AFSReleaseResource( &DirEntry->NonPaged->Lock);
3500         }
3501
3502 try_exit:
3503
3504         NOTHING;
3505     }
3506
3507     return ntStatus;
3508 }
3509
3510 NTSTATUS
3511 AFSValidateEntry( IN AFSDirectoryCB *DirEntry,
3512                   IN GUID *AuthGroup,
3513                   IN BOOLEAN PurgeContent,
3514                   IN BOOLEAN FastCall)
3515 {
3516
3517     NTSTATUS ntStatus = STATUS_SUCCESS;
3518     LARGE_INTEGER liSystemTime;
3519     AFSDirEnumEntry *pDirEnumEntry = NULL;
3520     AFSFcb *pCurrentFcb = NULL;
3521     BOOLEAN bReleaseFcb = FALSE;
3522     AFSObjectInfoCB *pObjectInfo = DirEntry->ObjectInformation;
3523
3524     __Enter
3525     {
3526
3527         //
3528         // If we have an Fcb hanging off the directory entry then be sure to acquire the locks in the
3529         // correct order
3530         //
3531
3532         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3533                       AFS_TRACE_LEVEL_VERBOSE_2,
3534                       "AFSValidateEntry Validating entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3535                       &DirEntry->NameInformation.FileName,
3536                       pObjectInfo->FileId.Cell,
3537                       pObjectInfo->FileId.Volume,
3538                       pObjectInfo->FileId.Vnode,
3539                       pObjectInfo->FileId.Unique);
3540
3541         //
3542         // If this is a fake node then bail since the service knows nothing about it
3543         //
3544
3545         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_FAKE))
3546         {
3547
3548             try_return( ntStatus);
3549         }
3550
3551         if( PurgeContent &&
3552             pObjectInfo->Fcb != NULL)
3553         {
3554
3555             pCurrentFcb = pObjectInfo->Fcb;
3556
3557             if( !ExIsResourceAcquiredLite( &pCurrentFcb->NPFcb->Resource))
3558             {
3559
3560                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3561                               AFS_TRACE_LEVEL_VERBOSE,
3562                               "AFSValidateEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
3563                               &pCurrentFcb->NPFcb->Resource,
3564                               PsGetCurrentThread());
3565
3566                 AFSAcquireExcl( &pCurrentFcb->NPFcb->Resource,
3567                                 TRUE);
3568
3569                 bReleaseFcb = TRUE;
3570             }
3571         }
3572
3573         //
3574         // This routine ensures that the current entry is valid by:
3575         //
3576         //      1) Checking that the expiration time is non-zero and after where we
3577         //         currently are
3578         //
3579
3580         KeQuerySystemTime( &liSystemTime);
3581
3582         if( !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) &&
3583             !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY) &&
3584             !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA) &&
3585             pObjectInfo->Expiration.QuadPart >= liSystemTime.QuadPart)
3586         {
3587
3588             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3589                           AFS_TRACE_LEVEL_VERBOSE_2,
3590                           "AFSValidateEntry Directory entry %wZ FID %08lX-%08lX-%08lX-%08lX VALID\n",
3591                           &DirEntry->NameInformation.FileName,
3592                           pObjectInfo->FileId.Cell,
3593                           pObjectInfo->FileId.Volume,
3594                           pObjectInfo->FileId.Vnode,
3595                           pObjectInfo->FileId.Unique);
3596
3597             try_return( ntStatus);
3598         }
3599
3600         //
3601         // This node requires updating
3602         //
3603
3604         ntStatus = AFSEvaluateTargetByID( pObjectInfo,
3605                                           AuthGroup,
3606                                           FastCall,
3607                                           &pDirEnumEntry);
3608
3609         if( !NT_SUCCESS( ntStatus))
3610         {
3611
3612             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3613                           AFS_TRACE_LEVEL_ERROR,
3614                           "AFSValidateEntry Failed to evaluate entry %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3615                           &DirEntry->NameInformation.FileName,
3616                           pObjectInfo->FileId.Cell,
3617                           pObjectInfo->FileId.Volume,
3618                           pObjectInfo->FileId.Vnode,
3619                           pObjectInfo->FileId.Unique,
3620                           ntStatus);
3621
3622             //
3623             // Failed validation of node so return access-denied
3624             //
3625
3626             try_return( ntStatus);
3627         }
3628
3629         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3630                       AFS_TRACE_LEVEL_VERBOSE,
3631                       "AFSValidateEntry Validating entry %wZ FID %08lX-%08lX-%08lX-%08lX DV %I64X returned DV %I64X FT %d\n",
3632                       &DirEntry->NameInformation.FileName,
3633                       pObjectInfo->FileId.Cell,
3634                       pObjectInfo->FileId.Volume,
3635                       pObjectInfo->FileId.Vnode,
3636                       pObjectInfo->FileId.Unique,
3637                       pObjectInfo->DataVersion.QuadPart,
3638                       pDirEnumEntry->DataVersion.QuadPart,
3639                       pDirEnumEntry->FileType);
3640
3641
3642         //
3643         // Based on the file type, process the node
3644         //
3645
3646         switch( pDirEnumEntry->FileType)
3647         {
3648
3649             case AFS_FILE_TYPE_MOUNTPOINT:
3650             {
3651
3652                 //
3653                 // Update the metadata for the entry
3654                 //
3655
3656                 ntStatus = AFSUpdateMetaData( DirEntry,
3657                                               pDirEnumEntry);
3658
3659                 if( NT_SUCCESS( ntStatus))
3660                 {
3661
3662                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
3663                 }
3664
3665                 break;
3666             }
3667
3668             case AFS_FILE_TYPE_SYMLINK:
3669             case AFS_FILE_TYPE_DFSLINK:
3670             {
3671
3672                 //
3673                 // Update the metadata for the entry
3674                 //
3675
3676                 ntStatus = AFSUpdateMetaData( DirEntry,
3677                                               pDirEnumEntry);
3678
3679                 if( NT_SUCCESS( ntStatus))
3680                 {
3681
3682                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
3683                 }
3684
3685                 break;
3686             }
3687
3688             case AFS_FILE_TYPE_FILE:
3689             {
3690
3691                 //
3692                 // For a file where the data version has become invalid we need to
3693                 // fail any current extent requests and purge the cache for the file
3694                 // Can't hold the Fcb resource while doing this
3695                 //
3696
3697                 if( pCurrentFcb != NULL &&
3698                     (pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart ||
3699                     BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA)))
3700                 {
3701
3702                     IO_STATUS_BLOCK stIoStatus;
3703                     BOOLEAN bPurgeExtents = FALSE;
3704
3705                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3706                                   AFS_TRACE_LEVEL_VERBOSE_2,
3707                                   "AFSValidateEntry Flush/purge entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3708                                   &DirEntry->NameInformation.FileName,
3709                                   pObjectInfo->FileId.Cell,
3710                                   pObjectInfo->FileId.Volume,
3711                                   pObjectInfo->FileId.Vnode,
3712                                   pObjectInfo->FileId.Unique);
3713
3714                     if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
3715                     {
3716                         bPurgeExtents = TRUE;
3717
3718                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3719                                       AFS_TRACE_LEVEL_VERBOSE,
3720                                       "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3721                                       &DirEntry->NameInformation.FileName,
3722                                       pObjectInfo->FileId.Cell,
3723                                       pObjectInfo->FileId.Volume,
3724                                       pObjectInfo->FileId.Vnode,
3725                                       pObjectInfo->FileId.Unique);
3726
3727                         ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
3728                     }
3729
3730                     __try
3731                     {
3732
3733                         CcFlushCache( &pCurrentFcb->NPFcb->SectionObjectPointers,
3734                                       NULL,
3735                                       0,
3736                                       &stIoStatus);
3737
3738                         if( !NT_SUCCESS( stIoStatus.Status))
3739                         {
3740
3741                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
3742                                           AFS_TRACE_LEVEL_ERROR,
3743                                           "AFSValidateEntry CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
3744                                           &DirEntry->NameInformation.FileName,
3745                                           pObjectInfo->FileId.Cell,
3746                                           pObjectInfo->FileId.Volume,
3747                                           pObjectInfo->FileId.Vnode,
3748                                           pObjectInfo->FileId.Unique,
3749                                           stIoStatus.Status,
3750                                           stIoStatus.Information);
3751
3752                             ntStatus = stIoStatus.Status;
3753                         }
3754
3755                         if ( bPurgeExtents)
3756                         {
3757
3758                             CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
3759                                                  NULL,
3760                                                  0,
3761                                                  FALSE);
3762                         }
3763                     }
3764                     __except( EXCEPTION_EXECUTE_HANDLER)
3765                     {
3766                         ntStatus = GetExceptionCode();
3767
3768                         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
3769                                       AFS_TRACE_LEVEL_ERROR,
3770                                       "AFSValidateEntry CcFlushCache or CcPurgeCacheSection exception %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
3771                                       &DirEntry->NameInformation.FileName,
3772                                       pObjectInfo->FileId.Cell,
3773                                       pObjectInfo->FileId.Volume,
3774                                       pObjectInfo->FileId.Vnode,
3775                                       pObjectInfo->FileId.Unique,
3776                                       ntStatus);
3777
3778                     }
3779
3780                     AFSReleaseResource( &pCurrentFcb->NPFcb->Resource);
3781
3782                     if ( bPurgeExtents)
3783                     {
3784                         AFSFlushExtents( pCurrentFcb);
3785                     }
3786
3787                     //
3788                     // Reacquire the Fcb to purge the cache
3789                     //
3790
3791                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3792                                   AFS_TRACE_LEVEL_VERBOSE,
3793                                   "AFSValidateEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
3794                                   &pCurrentFcb->NPFcb->Resource,
3795                                   PsGetCurrentThread());
3796
3797                     AFSAcquireExcl( &pCurrentFcb->NPFcb->Resource,
3798                                     TRUE);
3799                 }
3800
3801                 //
3802                 // Update the metadata for the entry
3803                 //
3804
3805                 ntStatus = AFSUpdateMetaData( DirEntry,
3806                                               pDirEnumEntry);
3807
3808                 if( !NT_SUCCESS( ntStatus))
3809                 {
3810
3811                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3812                                   AFS_TRACE_LEVEL_ERROR,
3813                                   "AFSValidateEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
3814                                   &DirEntry->NameInformation.FileName,
3815                                   pObjectInfo->FileId.Cell,
3816                                   pObjectInfo->FileId.Volume,
3817                                   pObjectInfo->FileId.Vnode,
3818                                   pObjectInfo->FileId.Unique,
3819                                   ntStatus);
3820
3821                     break;
3822                 }
3823
3824                 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
3825
3826                 //
3827                 // Update file sizes
3828                 //
3829
3830                 if( pObjectInfo->Fcb != NULL)
3831                 {
3832                     FILE_OBJECT *pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
3833
3834                     pObjectInfo->Fcb->Header.AllocationSize.QuadPart  = pObjectInfo->AllocationSize.QuadPart;
3835                     pObjectInfo->Fcb->Header.FileSize.QuadPart        = pObjectInfo->EndOfFile.QuadPart;
3836                     pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
3837
3838                     if ( pCCFileObject != NULL)
3839                     {
3840                         CcSetFileSizes( pCCFileObject,
3841                                         (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
3842                     }
3843                 }
3844
3845                 break;
3846             }
3847
3848             case AFS_FILE_TYPE_DIRECTORY:
3849             {
3850
3851                 AFSDirectoryCB *pCurrentDirEntry = NULL;
3852
3853                 if( pCurrentFcb != NULL &&
3854                     pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
3855                 {
3856
3857                     //
3858                     // For a directory or root entry flush the content of
3859                     // the directory enumeration.
3860                     //
3861
3862                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3863                                   AFS_TRACE_LEVEL_VERBOSE,
3864                                   "AFSValidateEntry Acquiring DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
3865                                   pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
3866                                   PsGetCurrentThread());
3867
3868                     if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
3869                     {
3870
3871                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3872                                       AFS_TRACE_LEVEL_VERBOSE_2,
3873                                       "AFSValidateEntry Validating directory content for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3874                                       &DirEntry->NameInformation.FileName,
3875                                       pObjectInfo->FileId.Cell,
3876                                       pObjectInfo->FileId.Volume,
3877                                       pObjectInfo->FileId.Vnode,
3878                                       pObjectInfo->FileId.Unique);
3879
3880                         AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
3881                                         TRUE);
3882
3883                         AFSValidateDirectoryCache( pCurrentFcb->ObjectInformation,
3884                                                    AuthGroup);
3885
3886                         AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
3887                     }
3888
3889                     if( !NT_SUCCESS( ntStatus))
3890                     {
3891
3892                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3893                                       AFS_TRACE_LEVEL_ERROR,
3894                                       "AFSValidateEntry Failed to re-enumerate %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3895                                       &DirEntry->NameInformation.FileName,
3896                                       pObjectInfo->FileId.Cell,
3897                                       pObjectInfo->FileId.Volume,
3898                                       pObjectInfo->FileId.Vnode,
3899                                       pObjectInfo->FileId.Unique,
3900                                       ntStatus);
3901
3902                         break;
3903                     }
3904                 }
3905
3906                 //
3907                 // Update the metadata for the entry
3908                 //
3909
3910                 ntStatus = AFSUpdateMetaData( DirEntry,
3911                                               pDirEnumEntry);
3912
3913                 if( NT_SUCCESS( ntStatus))
3914                 {
3915
3916                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
3917                 }
3918
3919                 break;
3920             }
3921
3922             default:
3923
3924                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3925                               AFS_TRACE_LEVEL_WARNING,
3926                               "AFSValidateEntry Attempt to verify node of type %d\n",
3927                               pObjectInfo->FileType);
3928
3929                 break;
3930         }
3931
3932  try_exit:
3933
3934         if( bReleaseFcb)
3935         {
3936
3937             AFSReleaseResource( &pCurrentFcb->NPFcb->Resource);
3938         }
3939
3940         if( pDirEnumEntry != NULL)
3941         {
3942
3943             AFSExFreePool( pDirEnumEntry);
3944         }
3945     }
3946
3947     return ntStatus;
3948 }
3949
3950 NTSTATUS
3951 AFSInitializeSpecialShareNameList()
3952 {
3953
3954     NTSTATUS ntStatus = STATUS_SUCCESS;
3955     AFSDirectoryCB *pDirNode = NULL, *pLastDirNode = NULL;
3956     AFSObjectInfoCB *pObjectInfoCB = NULL;
3957     UNICODE_STRING uniShareName;
3958     ULONG ulEntryLength = 0;
3959     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
3960
3961     __Enter
3962     {
3963
3964         RtlInitUnicodeString( &uniShareName,
3965                               L"PIPE\\srvsvc");
3966
3967         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
3968                                                0);
3969
3970         if( pObjectInfoCB == NULL)
3971         {
3972
3973             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3974         }
3975
3976         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3977                       AFS_TRACE_LEVEL_VERBOSE,
3978                       "AFSInitializeSpecialShareNameList (srvsvc) Initializing count (1) on object %08lX\n",
3979                       pObjectInfoCB);
3980
3981         pObjectInfoCB->ObjectReferenceCount = 1;
3982
3983         pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
3984
3985         ulEntryLength = sizeof( AFSDirectoryCB) +
3986                                      uniShareName.Length;
3987
3988         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
3989                                                                   ulEntryLength,
3990                                                                   AFS_DIR_ENTRY_TAG);
3991
3992         if( pDirNode == NULL)
3993         {
3994
3995             AFSDeleteObjectInfo( pObjectInfoCB);
3996
3997             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3998         }
3999
4000         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
4001                                                                                    sizeof( AFSNonPagedDirectoryCB),
4002                                                                                    AFS_DIR_ENTRY_NP_TAG);
4003
4004         if( pNonPagedDirEntry == NULL)
4005         {
4006
4007             ExFreePool( pDirNode);
4008
4009             AFSDeleteObjectInfo( pObjectInfoCB);
4010
4011             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4012         }
4013
4014         RtlZeroMemory( pDirNode,
4015                        ulEntryLength);
4016
4017         RtlZeroMemory( pNonPagedDirEntry,
4018                        sizeof( AFSNonPagedDirectoryCB));
4019
4020         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
4021
4022         pDirNode->NonPaged = pNonPagedDirEntry;
4023
4024         pDirNode->ObjectInformation = pObjectInfoCB;
4025
4026         //
4027         // Set valid entry
4028         //
4029
4030         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_SERVER_SERVICE);
4031
4032         pDirNode->NameInformation.FileName.Length = uniShareName.Length;
4033
4034         pDirNode->NameInformation.FileName.MaximumLength = uniShareName.Length;
4035
4036         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
4037
4038         RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
4039                        uniShareName.Buffer,
4040                        pDirNode->NameInformation.FileName.Length);
4041
4042         pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
4043                                                                        TRUE);
4044
4045         AFSSpecialShareNames = pDirNode;
4046
4047         pLastDirNode = pDirNode;
4048
4049         RtlInitUnicodeString( &uniShareName,
4050                               L"PIPE\\wkssvc");
4051
4052         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
4053                                                0);
4054
4055         if( pObjectInfoCB == NULL)
4056         {
4057
4058             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4059         }
4060
4061         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
4062                       AFS_TRACE_LEVEL_VERBOSE,
4063                       "AFSInitializeSpecialShareNameList (wkssvc) Initializing count (1) on object %08lX\n",
4064                       pObjectInfoCB);
4065
4066         pObjectInfoCB->ObjectReferenceCount = 1;
4067
4068         pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
4069
4070         ulEntryLength = sizeof( AFSDirectoryCB) +
4071                                      uniShareName.Length;
4072
4073         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
4074                                                                   ulEntryLength,
4075                                                                   AFS_DIR_ENTRY_TAG);
4076
4077         if( pDirNode == NULL)
4078         {
4079
4080             AFSDeleteObjectInfo( pObjectInfoCB);
4081
4082             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4083         }
4084
4085         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
4086                                                                                    sizeof( AFSNonPagedDirectoryCB),
4087                                                                                    AFS_DIR_ENTRY_NP_TAG);
4088
4089         if( pNonPagedDirEntry == NULL)
4090         {
4091
4092             ExFreePool( pDirNode);
4093
4094             AFSDeleteObjectInfo( pObjectInfoCB);
4095
4096             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4097         }
4098
4099         RtlZeroMemory( pDirNode,
4100                        ulEntryLength);
4101
4102         RtlZeroMemory( pNonPagedDirEntry,
4103                        sizeof( AFSNonPagedDirectoryCB));
4104
4105         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
4106
4107         pDirNode->NonPaged = pNonPagedDirEntry;
4108
4109         pDirNode->ObjectInformation = pObjectInfoCB;
4110
4111         //
4112         // Set valid entry
4113         //
4114
4115         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_WORKSTATION_SERVICE);
4116
4117         pDirNode->NameInformation.FileName.Length = uniShareName.Length;
4118
4119         pDirNode->NameInformation.FileName.MaximumLength = uniShareName.Length;
4120
4121         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
4122
4123         RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
4124                        uniShareName.Buffer,
4125                        pDirNode->NameInformation.FileName.Length);
4126
4127         pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
4128                                                                        TRUE);
4129
4130         pLastDirNode->ListEntry.fLink = pDirNode;
4131
4132         pDirNode->ListEntry.bLink = pLastDirNode;
4133
4134         pLastDirNode = pDirNode;
4135
4136         RtlInitUnicodeString( &uniShareName,
4137                               L"IPC$");
4138
4139         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
4140                                                0);
4141
4142         if( pObjectInfoCB == NULL)
4143         {
4144
4145             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4146         }
4147
4148         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
4149                       AFS_TRACE_LEVEL_VERBOSE,
4150                       "AFSInitializeSpecialShareNameList (ipc$) Initializing count (1) on object %08lX\n",
4151                       pObjectInfoCB);
4152
4153         pObjectInfoCB->ObjectReferenceCount = 1;
4154
4155         pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
4156
4157         ulEntryLength = sizeof( AFSDirectoryCB) +
4158                                      uniShareName.Length;
4159
4160         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
4161                                                                   ulEntryLength,
4162                                                                   AFS_DIR_ENTRY_TAG);
4163
4164         if( pDirNode == NULL)
4165         {
4166
4167             AFSDeleteObjectInfo( pObjectInfoCB);
4168
4169             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4170         }
4171
4172         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
4173                                                                                    sizeof( AFSNonPagedDirectoryCB),
4174                                                                                    AFS_DIR_ENTRY_NP_TAG);
4175
4176         if( pNonPagedDirEntry == NULL)
4177         {
4178
4179             ExFreePool( pDirNode);
4180
4181             AFSDeleteObjectInfo( pObjectInfoCB);
4182
4183             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4184         }
4185
4186         RtlZeroMemory( pDirNode,
4187                        ulEntryLength);
4188
4189         RtlZeroMemory( pNonPagedDirEntry,
4190                        sizeof( AFSNonPagedDirectoryCB));
4191
4192         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
4193
4194         pDirNode->NonPaged = pNonPagedDirEntry;
4195
4196         pDirNode->ObjectInformation = pObjectInfoCB;
4197
4198         //
4199         // Set valid entry
4200         //
4201
4202         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_IPC);
4203
4204         pDirNode->NameInformation.FileName.Length = uniShareName.Length;
4205
4206         pDirNode->NameInformation.FileName.MaximumLength = uniShareName.Length;
4207
4208         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
4209
4210         RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
4211                        uniShareName.Buffer,
4212                        pDirNode->NameInformation.FileName.Length);
4213
4214         pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
4215                                                                        TRUE);
4216
4217         pLastDirNode->ListEntry.fLink = pDirNode;
4218
4219         pDirNode->ListEntry.bLink = pLastDirNode;
4220
4221 try_exit:
4222
4223         if( !NT_SUCCESS( ntStatus))
4224         {
4225
4226             if( AFSSpecialShareNames != NULL)
4227             {
4228
4229                 pDirNode = AFSSpecialShareNames;
4230
4231                 while( pDirNode != NULL)
4232                 {
4233
4234                     pLastDirNode = (AFSDirectoryCB *)pDirNode->ListEntry.fLink;
4235
4236                     AFSDeleteObjectInfo( pDirNode->ObjectInformation);
4237
4238                     ExDeleteResourceLite( &pDirNode->NonPaged->Lock);
4239
4240                     ExFreePool( pDirNode->NonPaged);
4241
4242                     ExFreePool( pDirNode);
4243
4244                     pDirNode = pLastDirNode;
4245                 }
4246
4247                 AFSSpecialShareNames = NULL;
4248             }
4249         }
4250     }
4251
4252     return ntStatus;
4253 }
4254
4255 AFSDirectoryCB *
4256 AFSGetSpecialShareNameEntry( IN UNICODE_STRING *ShareName,
4257                              IN UNICODE_STRING *SecondaryName)
4258 {
4259
4260     AFSDirectoryCB *pDirectoryCB = NULL;
4261     ULONGLONG ullHash = 0;
4262     UNICODE_STRING uniFullShareName;
4263
4264     __Enter
4265     {
4266
4267         //
4268         // Build up the entire name here. We are guaranteed that if there is a
4269         // secondary name, it is pointing to a portion of the share name buffer
4270         //
4271
4272         if( SecondaryName->Length > 0 &&
4273             SecondaryName->Buffer != NULL)
4274         {
4275
4276             uniFullShareName = *SecondaryName;
4277
4278             //
4279             // The calling routine strips off the leading slash so add it back in
4280             //
4281
4282             uniFullShareName.Buffer--;
4283             uniFullShareName.Length += sizeof( WCHAR);
4284             uniFullShareName.MaximumLength += sizeof( WCHAR);
4285
4286             //
4287             // And the share name
4288             //
4289
4290             uniFullShareName.Buffer -= (ShareName->Length/sizeof( WCHAR));
4291             uniFullShareName.Length += ShareName->Length;
4292             uniFullShareName.MaximumLength += ShareName->Length;
4293         }
4294         else
4295         {
4296
4297             uniFullShareName = *ShareName;
4298         }
4299
4300         //
4301         // Generate our hash value
4302         //
4303
4304         ullHash = AFSGenerateCRC( &uniFullShareName,
4305                                   TRUE);
4306
4307         //
4308         // Loop through our special share names to see if this is one of them
4309         //
4310
4311         pDirectoryCB = AFSSpecialShareNames;
4312
4313         while( pDirectoryCB != NULL)
4314         {
4315
4316             if( ullHash == pDirectoryCB->CaseInsensitiveTreeEntry.HashIndex)
4317             {
4318
4319                 break;
4320             }
4321
4322             pDirectoryCB = (AFSDirectoryCB *)pDirectoryCB->ListEntry.fLink;
4323         }
4324     }
4325
4326     return pDirectoryCB;
4327 }
4328
4329 void
4330 AFSWaitOnQueuedFlushes( IN AFSFcb *Fcb)
4331 {
4332
4333     //
4334     // Block on the queue flush event
4335     //
4336
4337     KeWaitForSingleObject( &Fcb->NPFcb->Specific.File.QueuedFlushEvent,
4338                            Executive,
4339                            KernelMode,
4340                            FALSE,
4341                            NULL);
4342
4343     return;
4344 }
4345
4346 void
4347 AFSWaitOnQueuedReleases()
4348 {
4349
4350     AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
4351
4352     //
4353     // Block on the queue flush event
4354     //
4355
4356     KeWaitForSingleObject( &pRDRDeviceExt->Specific.RDR.QueuedReleaseExtentEvent,
4357                            Executive,
4358                            KernelMode,
4359                            FALSE,
4360                            NULL);
4361
4362     return;
4363 }
4364
4365 BOOLEAN
4366 AFSIsEqualFID( IN AFSFileID *FileId1,
4367                IN AFSFileID *FileId2)
4368 {
4369
4370     BOOLEAN bIsEqual = FALSE;
4371
4372     if( FileId1->Unique == FileId2->Unique &&
4373         FileId1->Vnode == FileId2->Vnode &&
4374         FileId1->Volume == FileId2->Volume &&
4375         FileId1->Cell == FileId2->Cell)
4376     {
4377
4378         bIsEqual = TRUE;
4379     }
4380
4381     return bIsEqual;
4382 }
4383
4384 NTSTATUS
4385 AFSResetDirectoryContent( IN AFSObjectInfoCB *ObjectInfoCB)
4386 {
4387
4388     NTSTATUS ntStatus = STATUS_SUCCESS;
4389     AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
4390
4391     __Enter
4392     {
4393
4394         ASSERT( ExIsResourceAcquiredExclusiveLite( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock));
4395
4396         //
4397         // Reset the directory list information
4398         //
4399
4400         pCurrentDirEntry = ObjectInfoCB->Specific.Directory.DirectoryNodeListHead;
4401
4402         while( pCurrentDirEntry != NULL)
4403         {
4404
4405             pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
4406
4407             if( pCurrentDirEntry->OpenReferenceCount == 0)
4408             {
4409
4410                 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
4411                               AFS_TRACE_LEVEL_VERBOSE,
4412                               "AFSResetDirectoryContent Deleting dir entry %p for %wZ\n",
4413                               pCurrentDirEntry,
4414                               &pCurrentDirEntry->NameInformation.FileName);
4415
4416                 AFSDeleteDirEntry( ObjectInfoCB,
4417                                    pCurrentDirEntry);
4418             }
4419             else
4420             {
4421
4422                 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
4423                               AFS_TRACE_LEVEL_VERBOSE,
4424                               "AFSResetDirectoryContent Setting DELETE flag in dir entry %p for %wZ\n",
4425                               pCurrentDirEntry,
4426                               &pCurrentDirEntry->NameInformation.FileName);
4427
4428                 SetFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
4429
4430                 AFSRemoveNameEntry( ObjectInfoCB,
4431                                     pCurrentDirEntry);
4432             }
4433
4434             pCurrentDirEntry = pNextDirEntry;
4435         }
4436
4437         ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = NULL;
4438
4439         ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = NULL;
4440
4441         ObjectInfoCB->Specific.Directory.ShortNameTree = NULL;
4442
4443         ObjectInfoCB->Specific.Directory.DirectoryNodeListHead = NULL;
4444
4445         ObjectInfoCB->Specific.Directory.DirectoryNodeListTail = NULL;
4446
4447         ObjectInfoCB->Specific.Directory.DirectoryNodeCount = 0;
4448
4449         AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
4450                       AFS_TRACE_LEVEL_VERBOSE,
4451                       "AFSResetDirectoryContent Reset count to 0 on parent FID %08lX-%08lX-%08lX-%08lX\n",
4452                       ObjectInfoCB->FileId.Cell,
4453                       ObjectInfoCB->FileId.Volume,
4454                       ObjectInfoCB->FileId.Vnode,
4455                       ObjectInfoCB->FileId.Unique);
4456     }
4457
4458     return ntStatus;
4459 }
4460
4461 NTSTATUS
4462 AFSEnumerateGlobalRoot( IN GUID *AuthGroup)
4463 {
4464
4465     NTSTATUS ntStatus = STATUS_SUCCESS;
4466     AFSDirectoryCB *pDirGlobalDirNode = NULL;
4467     UNICODE_STRING uniFullName;
4468
4469     __Enter
4470     {
4471
4472         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
4473                       AFS_TRACE_LEVEL_VERBOSE,
4474                       "AFSEnumerateGlobalRoot Acquiring GlobalRoot DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
4475                       AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
4476                       PsGetCurrentThread());
4477
4478         AFSAcquireExcl( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
4479                         TRUE);
4480
4481         if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
4482         {
4483
4484             try_return( ntStatus);
4485         }
4486
4487         //
4488         // Initialize the root information
4489         //
4490
4491         AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.ContentIndex = 1;
4492
4493         //
4494         // Enumerate the shares in the volume
4495         //
4496
4497         ntStatus = AFSEnumerateDirectory( AuthGroup,
4498                                           &AFSGlobalRoot->ObjectInformation,
4499                                           TRUE);
4500
4501         if( !NT_SUCCESS( ntStatus))
4502         {
4503
4504             try_return( ntStatus);
4505         }
4506
4507         pDirGlobalDirNode = AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead;
4508
4509         //
4510         // Indicate the node is initialized
4511         //
4512
4513         SetFlag( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
4514
4515         uniFullName.MaximumLength = PAGE_SIZE;
4516         uniFullName.Length = 0;
4517
4518         uniFullName.Buffer = (WCHAR *)AFSLibExAllocatePoolWithTag( PagedPool,
4519                                                                    uniFullName.MaximumLength,
4520                                                                    AFS_GENERIC_MEMORY_12_TAG);
4521
4522         if( uniFullName.Buffer == NULL)
4523         {
4524
4525             //
4526             // Reset the directory content
4527             //
4528
4529             AFSResetDirectoryContent( &AFSGlobalRoot->ObjectInformation);
4530
4531             ClearFlag( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
4532
4533             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4534         }
4535
4536         //
4537         // Populate our list of entries in the NP enumeration list
4538         //
4539
4540         while( pDirGlobalDirNode != NULL)
4541         {
4542
4543             uniFullName.Buffer[ 0] = L'\\';
4544             uniFullName.Buffer[ 1] = L'\\';
4545
4546             uniFullName.Length = 2 * sizeof( WCHAR);
4547
4548             RtlCopyMemory( &uniFullName.Buffer[ 2],
4549                            AFSServerName.Buffer,
4550                            AFSServerName.Length);
4551
4552             uniFullName.Length += AFSServerName.Length;
4553
4554             uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)] = L'\\';
4555
4556             uniFullName.Length += sizeof( WCHAR);
4557
4558             RtlCopyMemory( &uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)],
4559                            pDirGlobalDirNode->NameInformation.FileName.Buffer,
4560                            pDirGlobalDirNode->NameInformation.FileName.Length);
4561
4562             uniFullName.Length += pDirGlobalDirNode->NameInformation.FileName.Length;
4563
4564             AFSAddConnectionEx( &uniFullName,
4565                                 RESOURCEDISPLAYTYPE_SHARE,
4566                                 0);
4567
4568             pDirGlobalDirNode = (AFSDirectoryCB *)pDirGlobalDirNode->ListEntry.fLink;
4569         }
4570
4571         AFSExFreePool( uniFullName.Buffer);
4572
4573 try_exit:
4574
4575         AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
4576     }
4577
4578     return ntStatus;
4579 }
4580
4581 BOOLEAN
4582 AFSIsRelativeName( IN UNICODE_STRING *Name)
4583 {
4584
4585     BOOLEAN bIsRelative = FALSE;
4586
4587     if( Name->Buffer[ 0] != L'\\')
4588     {
4589
4590         bIsRelative = TRUE;
4591     }
4592
4593     return bIsRelative;
4594 }
4595
4596 void
4597 AFSUpdateName( IN UNICODE_STRING *Name)
4598 {
4599
4600     USHORT usIndex = 0;
4601
4602     while( usIndex < Name->Length/sizeof( WCHAR))
4603     {
4604
4605         if( Name->Buffer[ usIndex] == L'/')
4606         {
4607
4608             Name->Buffer[ usIndex] = L'\\';
4609         }
4610
4611         usIndex++;
4612     }
4613
4614     return;
4615 }
4616
4617 NTSTATUS
4618 AFSUpdateTargetName( IN OUT UNICODE_STRING *TargetName,
4619                      IN OUT ULONG *Flags,
4620                      IN WCHAR *NameBuffer,
4621                      IN USHORT NameLength)
4622 {
4623
4624     NTSTATUS ntStatus = STATUS_SUCCESS;
4625     WCHAR *pTmpBuffer = NULL;
4626
4627     __Enter
4628     {
4629
4630         //
4631         // If we have enough space then just move in the name otherwise
4632         // allocate a new buffer
4633         //
4634
4635         if( TargetName->Length < NameLength)
4636         {
4637
4638             pTmpBuffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
4639                                                             NameLength,
4640                                                             AFS_NAME_BUFFER_FIVE_TAG);
4641
4642             if( pTmpBuffer == NULL)
4643             {
4644
4645                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4646             }
4647
4648             if( BooleanFlagOn( *Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
4649             {
4650
4651                 AFSExFreePool( TargetName->Buffer);
4652             }
4653
4654             TargetName->MaximumLength = NameLength;
4655
4656             TargetName->Buffer = pTmpBuffer;
4657
4658             SetFlag( *Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER);
4659         }
4660
4661         TargetName->Length = NameLength;
4662
4663         RtlCopyMemory( TargetName->Buffer,
4664                        NameBuffer,
4665                        TargetName->Length);
4666
4667         //
4668         // Update the name in the buffer
4669         //
4670
4671         AFSUpdateName( TargetName);
4672
4673 try_exit:
4674
4675         NOTHING;
4676     }
4677
4678     return ntStatus;
4679 }
4680
4681 AFSNameArrayHdr *
4682 AFSInitNameArray( IN AFSDirectoryCB *DirectoryCB,
4683                   IN ULONG InitialElementCount)
4684 {
4685
4686     AFSNameArrayHdr *pNameArray = NULL;
4687     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4688
4689     __Enter
4690     {
4691
4692         if( InitialElementCount == 0)
4693         {
4694
4695             InitialElementCount = pDevExt->Specific.RDR.NameArrayLength;
4696         }
4697
4698         pNameArray = (AFSNameArrayHdr *)AFSExAllocatePoolWithTag( PagedPool,
4699                                                                   sizeof( AFSNameArrayHdr) +
4700                                                                     (InitialElementCount * sizeof( AFSNameArrayCB)),
4701                                                                   AFS_NAME_ARRAY_TAG);
4702
4703         if( pNameArray == NULL)
4704         {
4705
4706             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4707                           AFS_TRACE_LEVEL_ERROR,
4708                           "AFSInitNameArray Failed to allocate name array\n");
4709
4710             try_return( pNameArray);
4711         }
4712
4713         RtlZeroMemory( pNameArray,
4714                        sizeof( AFSNameArrayHdr) +
4715                           (InitialElementCount * sizeof( AFSNameArrayCB)));
4716
4717         pNameArray->MaxElementCount = InitialElementCount;
4718
4719         if( DirectoryCB != NULL)
4720         {
4721
4722             pNameArray->CurrentEntry = &pNameArray->ElementArray[ 0];
4723
4724             InterlockedIncrement( &pNameArray->Count);
4725
4726             InterlockedIncrement( &DirectoryCB->OpenReferenceCount);
4727
4728             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4729                           AFS_TRACE_LEVEL_VERBOSE,
4730                           "AFSInitNameArray Increment count on %wZ DE %p Cnt %d\n",
4731                           &DirectoryCB->NameInformation.FileName,
4732                           DirectoryCB,
4733                           DirectoryCB->OpenReferenceCount);
4734
4735             pNameArray->CurrentEntry->DirectoryCB = DirectoryCB;
4736
4737             pNameArray->CurrentEntry->Component = DirectoryCB->NameInformation.FileName;
4738
4739             pNameArray->CurrentEntry->FileId = DirectoryCB->ObjectInformation->FileId;
4740         }
4741
4742 try_exit:
4743
4744         NOTHING;
4745     }
4746
4747     return pNameArray;
4748 }
4749
4750 NTSTATUS
4751 AFSPopulateNameArray( IN AFSNameArrayHdr *NameArray,
4752                       IN UNICODE_STRING *Path,
4753                       IN AFSDirectoryCB *DirectoryCB)
4754 {
4755
4756     NTSTATUS ntStatus = STATUS_SUCCESS;
4757     AFSNameArrayCB *pCurrentElement = NULL;
4758     UNICODE_STRING uniComponentName, uniRemainingPath;
4759     AFSObjectInfoCB *pCurrentObject = NULL;
4760     ULONG  ulTotalCount = 0;
4761     ULONG ulIndex = 0;
4762     USHORT usLength = 0;
4763
4764     __Enter
4765     {
4766
4767         //
4768         // Init some info in the header
4769         //
4770
4771         pCurrentElement = &NameArray->ElementArray[ 0];
4772
4773         NameArray->CurrentEntry = pCurrentElement;
4774
4775         //
4776         // The first entry points at the root
4777         //
4778
4779         pCurrentElement->DirectoryCB = DirectoryCB->ObjectInformation->VolumeCB->DirectoryCB;
4780
4781         InterlockedIncrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
4782
4783         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4784                       AFS_TRACE_LEVEL_VERBOSE,
4785                       "AFSPopulateNameArray Increment count on volume %wZ DE %p Cnt %d\n",
4786                       &pCurrentElement->DirectoryCB->NameInformation.FileName,
4787                       pCurrentElement->DirectoryCB,
4788                       pCurrentElement->DirectoryCB->OpenReferenceCount);
4789
4790         pCurrentElement->Component = DirectoryCB->ObjectInformation->VolumeCB->DirectoryCB->NameInformation.FileName;
4791
4792         pCurrentElement->FileId = DirectoryCB->ObjectInformation->VolumeCB->ObjectInformation.FileId;
4793
4794         NameArray->Count = 1;
4795
4796         NameArray->LinkCount = 0;
4797
4798         //
4799         // If the root is the parent then we are done ...
4800         //
4801
4802         if( &DirectoryCB->ObjectInformation->VolumeCB->ObjectInformation == DirectoryCB->ObjectInformation)
4803         {
4804             try_return( ntStatus);
4805         }
4806
4807 try_exit:
4808
4809         NOTHING;
4810     }
4811
4812     return ntStatus;
4813 }
4814
4815 NTSTATUS
4816 AFSPopulateNameArrayFromRelatedArray( IN AFSNameArrayHdr *NameArray,
4817                                       IN AFSNameArrayHdr *RelatedNameArray,
4818                                       IN AFSDirectoryCB *DirectoryCB)
4819 {
4820
4821     NTSTATUS ntStatus = STATUS_SUCCESS;
4822     AFSNameArrayCB *pCurrentElement = NULL, *pCurrentRelatedElement = NULL;
4823     UNICODE_STRING uniComponentName, uniRemainingPath;
4824     AFSObjectInfoCB *pObjectInfo = NULL;
4825     ULONG  ulTotalCount = 0;
4826     ULONG ulIndex = 0;
4827     USHORT usLength = 0;
4828
4829     __Enter
4830     {
4831
4832         //
4833         // Init some info in the header
4834         //
4835
4836         pCurrentElement = &NameArray->ElementArray[ 0];
4837
4838         pCurrentRelatedElement = &RelatedNameArray->ElementArray[ 0];
4839
4840         NameArray->Count = 0;
4841
4842         NameArray->LinkCount = RelatedNameArray->LinkCount;
4843
4844         //
4845         // Populate the name array with the data from the related array
4846         //
4847
4848         while( TRUE)
4849         {
4850
4851             pCurrentElement->DirectoryCB = pCurrentRelatedElement->DirectoryCB;
4852
4853             pCurrentElement->Component = pCurrentRelatedElement->DirectoryCB->NameInformation.FileName;
4854
4855             pCurrentElement->FileId    = pCurrentElement->DirectoryCB->ObjectInformation->FileId;
4856
4857             InterlockedIncrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
4858
4859             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4860                           AFS_TRACE_LEVEL_VERBOSE,
4861                           "AFSPopulateNameArrayFromRelatedArray Increment count on %wZ DE %p Cnt %d\n",
4862                           &pCurrentElement->DirectoryCB->NameInformation.FileName,
4863                           pCurrentElement->DirectoryCB,
4864                           pCurrentElement->DirectoryCB->OpenReferenceCount);
4865
4866             InterlockedIncrement( &NameArray->Count);
4867
4868             if( pCurrentElement->DirectoryCB == DirectoryCB ||
4869                 NameArray->Count == RelatedNameArray->Count)
4870             {
4871
4872                 //
4873                 // Done ...
4874                 //
4875
4876                 break;
4877             }
4878
4879             pCurrentElement++;
4880
4881             pCurrentRelatedElement++;
4882         }
4883
4884         if( NameArray->Count > 0)
4885         {
4886             NameArray->CurrentEntry = pCurrentElement;
4887         }
4888     }
4889
4890     return ntStatus;
4891 }
4892
4893 NTSTATUS
4894 AFSFreeNameArray( IN AFSNameArrayHdr *NameArray)
4895 {
4896
4897     NTSTATUS ntStatus = STATUS_SUCCESS;
4898     AFSNameArrayCB *pCurrentElement = NULL;
4899
4900     __Enter
4901     {
4902
4903         pCurrentElement = &NameArray->ElementArray[ 0];
4904
4905         while( TRUE)
4906         {
4907
4908             if( pCurrentElement->DirectoryCB == NULL)
4909             {
4910
4911                 break;
4912             }
4913
4914             InterlockedDecrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
4915
4916             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4917                           AFS_TRACE_LEVEL_VERBOSE,
4918                           "AFSFreeNameArray Decrement count on %wZ DE %p Cnt %d\n",
4919                           &pCurrentElement->DirectoryCB->NameInformation.FileName,
4920                           pCurrentElement->DirectoryCB,
4921                           pCurrentElement->DirectoryCB->OpenReferenceCount);
4922
4923             pCurrentElement++;
4924         }
4925
4926         AFSExFreePool( NameArray);
4927     }
4928
4929     return ntStatus;
4930 }
4931
4932 NTSTATUS
4933 AFSInsertNextElement( IN AFSNameArrayHdr *NameArray,
4934                       IN AFSDirectoryCB *DirEntry)
4935 {
4936
4937     NTSTATUS ntStatus = STATUS_SUCCESS;
4938     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4939
4940     __Enter
4941     {
4942
4943         if( NameArray->Count == NameArray->MaxElementCount)
4944         {
4945
4946             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4947         }
4948
4949         if( NameArray->CurrentEntry != NULL &&
4950             NameArray->CurrentEntry->DirectoryCB == DirEntry)
4951         {
4952
4953             try_return( ntStatus);
4954         }
4955
4956         if( NameArray->Count > 0)
4957         {
4958
4959             NameArray->CurrentEntry++;
4960         }
4961         else
4962         {
4963             NameArray->CurrentEntry = &NameArray->ElementArray[ 0];
4964         }
4965
4966         InterlockedIncrement( &NameArray->Count);
4967
4968         InterlockedIncrement( &DirEntry->OpenReferenceCount);
4969
4970         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4971                       AFS_TRACE_LEVEL_VERBOSE,
4972                       "AFSInsertNextElement Increment count on %wZ DE %p Cnt %d\n",
4973                       &DirEntry->NameInformation.FileName,
4974                       DirEntry,
4975                       DirEntry->OpenReferenceCount);
4976
4977         NameArray->CurrentEntry->DirectoryCB = DirEntry;
4978
4979         NameArray->CurrentEntry->Component = DirEntry->NameInformation.FileName;
4980
4981         NameArray->CurrentEntry->FileId = DirEntry->ObjectInformation->FileId;
4982
4983 try_exit:
4984
4985         NOTHING;
4986     }
4987
4988     return ntStatus;
4989 }
4990
4991 void
4992 AFSReplaceCurrentElement( IN AFSNameArrayHdr *NameArray,
4993                           IN AFSDirectoryCB *DirectoryCB)
4994 {
4995
4996     ASSERT( NameArray->CurrentEntry != NULL);
4997
4998     InterlockedDecrement( &NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
4999
5000     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5001                   AFS_TRACE_LEVEL_VERBOSE,
5002                   "AFSReplaceCurrentElement Decrement count on %wZ DE %p Cnt %d\n",
5003                   &NameArray->CurrentEntry->DirectoryCB->NameInformation.FileName,
5004                   NameArray->CurrentEntry->DirectoryCB,
5005                   NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
5006
5007     InterlockedIncrement( &DirectoryCB->OpenReferenceCount);
5008
5009     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5010                   AFS_TRACE_LEVEL_VERBOSE,
5011                   "AFSReplaceCurrentElement Increment count on %wZ DE %p Cnt %d\n",
5012                   &DirectoryCB->NameInformation.FileName,
5013                   DirectoryCB,
5014                   DirectoryCB->OpenReferenceCount);
5015
5016     NameArray->CurrentEntry->DirectoryCB = DirectoryCB;
5017
5018     NameArray->CurrentEntry->Component = DirectoryCB->NameInformation.FileName;
5019
5020     NameArray->CurrentEntry->FileId = DirectoryCB->ObjectInformation->FileId;
5021
5022     if( DirectoryCB->ObjectInformation->ParentObjectInformation == NULL)
5023     {
5024
5025         SetFlag( NameArray->CurrentEntry->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
5026     }
5027
5028     return;
5029 }
5030
5031 AFSDirectoryCB *
5032 AFSBackupEntry( IN AFSNameArrayHdr *NameArray)
5033 {
5034
5035     AFSDirectoryCB *pCurrentDirEntry = NULL;
5036
5037     __Enter
5038     {
5039
5040         if( NameArray->Count == 0)
5041         {
5042             try_return( pCurrentDirEntry);
5043         }
5044
5045         InterlockedDecrement( &NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
5046
5047         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5048                       AFS_TRACE_LEVEL_VERBOSE,
5049                       "AFSBackupEntry Decrement count on %wZ DE %p Cnt %d\n",
5050                       &NameArray->CurrentEntry->DirectoryCB->NameInformation.FileName,
5051                       NameArray->CurrentEntry->DirectoryCB,
5052                       NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
5053
5054         NameArray->CurrentEntry->DirectoryCB = NULL;
5055
5056         if( InterlockedDecrement( &NameArray->Count) == 0)
5057         {
5058             NameArray->CurrentEntry = NULL;
5059         }
5060         else
5061         {
5062             NameArray->CurrentEntry--;
5063             pCurrentDirEntry = NameArray->CurrentEntry->DirectoryCB;
5064         }
5065
5066 try_exit:
5067
5068         NOTHING;
5069     }
5070
5071     return pCurrentDirEntry;
5072 }
5073
5074 AFSDirectoryCB *
5075 AFSGetParentEntry( IN AFSNameArrayHdr *NameArray)
5076 {
5077
5078     AFSDirectoryCB *pDirEntry = NULL;
5079     AFSNameArrayCB *pElement = NULL;
5080
5081     __Enter
5082     {
5083
5084         if( NameArray->Count == 0 ||
5085             NameArray->Count == 1)
5086         {
5087
5088             try_return( pDirEntry = NULL);
5089         }
5090
5091         pElement = &NameArray->ElementArray[ NameArray->Count - 2];
5092
5093         pDirEntry = pElement->DirectoryCB;
5094
5095 try_exit:
5096
5097         NOTHING;
5098     }
5099
5100     return pDirEntry;
5101 }
5102
5103 void
5104 AFSResetNameArray( IN AFSNameArrayHdr *NameArray,
5105                    IN AFSDirectoryCB *DirEntry)
5106 {
5107
5108     AFSNameArrayCB *pCurrentElement = NULL;
5109     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
5110
5111     __Enter
5112     {
5113
5114         pCurrentElement = &NameArray->ElementArray[ 0];
5115
5116         while( TRUE)
5117         {
5118
5119             if( pCurrentElement->DirectoryCB == NULL)
5120             {
5121
5122                 break;
5123             }
5124
5125             InterlockedDecrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
5126
5127             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5128                           AFS_TRACE_LEVEL_VERBOSE,
5129                           "AFSResetNameArray Decrement count on %wZ DE %p Cnt %d\n",
5130                           &pCurrentElement->DirectoryCB->NameInformation.FileName,
5131                           pCurrentElement->DirectoryCB,
5132                           pCurrentElement->DirectoryCB->OpenReferenceCount);
5133
5134             pCurrentElement++;
5135         }
5136
5137         RtlZeroMemory( NameArray,
5138                        sizeof( AFSNameArrayHdr) +
5139                           ((pDevExt->Specific.RDR.NameArrayLength - 1) * sizeof( AFSNameArrayCB)));
5140
5141         NameArray->MaxElementCount = pDevExt->Specific.RDR.NameArrayLength;
5142
5143         if( DirEntry != NULL)
5144         {
5145
5146             NameArray->CurrentEntry = &NameArray->ElementArray[ 0];
5147
5148             InterlockedIncrement( &NameArray->Count);
5149
5150             InterlockedIncrement( &DirEntry->OpenReferenceCount);
5151
5152             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5153                           AFS_TRACE_LEVEL_VERBOSE,
5154                           "AFSResetNameArray Increment count on %wZ DE %p Cnt %d\n",
5155                           &DirEntry->NameInformation.FileName,
5156                           DirEntry,
5157                           DirEntry->OpenReferenceCount);
5158
5159             NameArray->CurrentEntry->DirectoryCB = DirEntry;
5160
5161             NameArray->CurrentEntry->Component = DirEntry->NameInformation.FileName;
5162
5163             NameArray->CurrentEntry->FileId = DirEntry->ObjectInformation->FileId;
5164         }
5165     }
5166
5167     return;
5168 }
5169
5170 void
5171 AFSDumpNameArray( IN AFSNameArrayHdr *NameArray)
5172 {
5173
5174     AFSNameArrayCB *pCurrentElement = NULL;
5175
5176     pCurrentElement = &NameArray->ElementArray[ 0];
5177
5178     AFSPrint("AFSDumpNameArray Start (%d)\n", NameArray->Count);
5179
5180     while( pCurrentElement->DirectoryCB != NULL)
5181     {
5182
5183         AFSPrint("FID %08lX-%08lX-%08lX-%08lX %wZ\n",
5184                   pCurrentElement->FileId.Cell,
5185                   pCurrentElement->FileId.Volume,
5186                   pCurrentElement->FileId.Vnode,
5187                   pCurrentElement->FileId.Unique,
5188                   &pCurrentElement->DirectoryCB->NameInformation.FileName);
5189
5190         pCurrentElement++;
5191     }
5192
5193     AFSPrint("AFSDumpNameArray End\n\n");
5194
5195     return;
5196 }
5197
5198 void
5199 AFSSetEnumerationEvent( IN AFSFcb *Fcb)
5200 {
5201
5202     //
5203     // Depending on the type of node, set the event
5204     //
5205
5206     switch( Fcb->Header.NodeTypeCode)
5207     {
5208
5209         case AFS_DIRECTORY_FCB:
5210         {
5211
5212             KeSetEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
5213                         0,
5214                         FALSE);
5215
5216             InterlockedIncrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
5217
5218             break;
5219         }
5220
5221         case AFS_ROOT_FCB:
5222         case AFS_ROOT_ALL:
5223         {
5224
5225             KeSetEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
5226                         0,
5227                         FALSE);
5228
5229             InterlockedIncrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
5230
5231             break;
5232         }
5233     }
5234
5235     return;
5236 }
5237
5238 void
5239 AFSClearEnumerationEvent( IN AFSFcb *Fcb)
5240 {
5241
5242     //
5243     // Depending on the type of node, set the event
5244     //
5245
5246     switch( Fcb->Header.NodeTypeCode)
5247     {
5248
5249         case AFS_DIRECTORY_FCB:
5250         {
5251
5252             ASSERT( Fcb->NPFcb->Specific.Directory.DirectoryEnumCount > 0);
5253
5254             if( InterlockedDecrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount) == 0)
5255             {
5256
5257                 KeClearEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent);
5258             }
5259
5260             break;
5261         }
5262
5263         case AFS_ROOT_FCB:
5264         case AFS_ROOT_ALL:
5265         {
5266
5267             ASSERT( Fcb->NPFcb->Specific.Directory.DirectoryEnumCount > 0);
5268
5269             if( InterlockedDecrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount) == 0)
5270             {
5271
5272                 KeClearEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent);
5273             }
5274
5275             break;
5276         }
5277     }
5278
5279     return;
5280 }
5281
5282 BOOLEAN
5283 AFSIsEnumerationInProcess( IN AFSObjectInfoCB *ObjectInfo)
5284 {
5285
5286     BOOLEAN bIsInProcess = FALSE;
5287
5288     __Enter
5289     {
5290
5291         if( ObjectInfo->Fcb == NULL)
5292         {
5293
5294             try_return( bIsInProcess);
5295         }
5296
5297         //
5298         // Depending on the type of node, set the event
5299         //
5300
5301         switch( ObjectInfo->Fcb->Header.NodeTypeCode)
5302         {
5303
5304             case AFS_DIRECTORY_FCB:
5305             {
5306
5307                 if( KeReadStateEvent( &ObjectInfo->Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent))
5308                 {
5309
5310                     bIsInProcess = TRUE;
5311                 }
5312
5313                 break;
5314             }
5315
5316             case AFS_ROOT_FCB:
5317             case AFS_ROOT_ALL:
5318             {
5319
5320                 if( KeReadStateEvent( &ObjectInfo->Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent))
5321                 {
5322
5323                     bIsInProcess = TRUE;
5324                 }
5325
5326                 break;
5327             }
5328         }
5329
5330 try_exit:
5331
5332         NOTHING;
5333     }
5334
5335     return bIsInProcess;
5336 }
5337
5338 NTSTATUS
5339 AFSVerifyVolume( IN ULONGLONG ProcessId,
5340                  IN AFSVolumeCB *VolumeCB)
5341 {
5342
5343     NTSTATUS ntStatus = STATUS_SUCCESS;
5344
5345
5346     return ntStatus;
5347 }
5348
5349 NTSTATUS
5350 AFSInitPIOCtlDirectoryCB( IN AFSObjectInfoCB *ObjectInfo)
5351 {
5352
5353     NTSTATUS ntStatus = STATUS_SUCCESS;
5354     AFSObjectInfoCB *pObjectInfoCB = NULL;
5355     AFSDirectoryCB *pDirNode = NULL;
5356     ULONG ulEntryLength = 0;
5357     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
5358
5359     __Enter
5360     {
5361
5362         pObjectInfoCB = AFSAllocateObjectInfo( ObjectInfo,
5363                                                0);
5364
5365         if( pObjectInfoCB == NULL)
5366         {
5367
5368             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5369         }
5370
5371         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
5372                       AFS_TRACE_LEVEL_VERBOSE,
5373                       "AFSInitPIOCtlDirectoryCB Initializing count (1) on object %08lX\n",
5374                       pObjectInfoCB);
5375
5376         pObjectInfoCB->ObjectReferenceCount = 1;
5377
5378         pObjectInfoCB->FileType = AFS_FILE_TYPE_PIOCTL;
5379
5380         pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
5381
5382         ulEntryLength = sizeof( AFSDirectoryCB) + AFSPIOCtlName.Length;
5383
5384         pDirNode = (AFSDirectoryCB *)AFSExAllocatePoolWithTag( PagedPool,
5385                                                                ulEntryLength,
5386                                                                AFS_DIR_ENTRY_TAG);
5387
5388         if( pDirNode == NULL)
5389         {
5390
5391             AFSDeleteObjectInfo( pObjectInfoCB);
5392
5393             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5394         }
5395
5396         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
5397                                                                                 sizeof( AFSNonPagedDirectoryCB),
5398                                                                                 AFS_DIR_ENTRY_NP_TAG);
5399
5400         if( pNonPagedDirEntry == NULL)
5401         {
5402
5403             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5404         }
5405
5406         RtlZeroMemory( pDirNode,
5407                        ulEntryLength);
5408
5409         RtlZeroMemory( pNonPagedDirEntry,
5410                        sizeof( AFSNonPagedDirectoryCB));
5411
5412         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
5413
5414         pDirNode->NonPaged = pNonPagedDirEntry;
5415
5416         pDirNode->ObjectInformation = pObjectInfoCB;
5417
5418         pDirNode->FileIndex = (ULONG)AFS_DIR_ENTRY_PIOCTL_INDEX;
5419
5420         //
5421         // Set valid entry
5422         //
5423
5424         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_FAKE);
5425
5426         pDirNode->NameInformation.FileName.Length = AFSPIOCtlName.Length;
5427
5428         pDirNode->NameInformation.FileName.MaximumLength = AFSPIOCtlName.Length;
5429
5430         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
5431
5432         RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
5433                        AFSPIOCtlName.Buffer,
5434                        pDirNode->NameInformation.FileName.Length);
5435
5436         pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
5437                                                                        TRUE);
5438
5439         ObjectInfo->Specific.Directory.PIOCtlDirectoryCB = pDirNode;
5440
5441 try_exit:
5442
5443         if ( !NT_SUCCESS( ntStatus))
5444         {
5445
5446             if ( pDirNode != NULL)
5447             {
5448
5449                 AFSExFreePool( pDirNode);
5450             }
5451
5452             if ( pObjectInfoCB != NULL)
5453             {
5454
5455                 AFSDeleteObjectInfo( pObjectInfoCB);
5456             }
5457         }
5458     }
5459
5460     return ntStatus;
5461 }
5462
5463 NTSTATUS
5464 AFSRetrieveFileAttributes( IN AFSDirectoryCB *ParentDirectoryCB,
5465                            IN AFSDirectoryCB *DirectoryCB,
5466                            IN UNICODE_STRING *ParentPathName,
5467                            IN AFSNameArrayHdr *RelatedNameArray,
5468                            OUT AFSFileInfoCB *FileInfo)
5469 {
5470
5471     NTSTATUS ntStatus = STATUS_SUCCESS;
5472     AFSDirEnumEntry *pDirEntry = NULL, *pLastDirEntry = NULL;
5473     UNICODE_STRING uniFullPathName;
5474     AFSNameArrayHdr    *pNameArray = NULL;
5475     AFSVolumeCB *pVolumeCB = NULL;
5476     AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
5477     WCHAR *pwchBuffer = NULL;
5478     UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
5479     ULONG ulNameDifference = 0;
5480     GUID *pAuthGroup = NULL;
5481
5482     __Enter
5483     {
5484
5485         //
5486         // Retrieve a target name for the entry
5487         //
5488
5489         AFSAcquireShared( &DirectoryCB->NonPaged->Lock,
5490                           TRUE);
5491
5492         if( DirectoryCB->NameInformation.TargetName.Length == 0)
5493         {
5494
5495             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5496
5497             if( ParentDirectoryCB->ObjectInformation->Fcb != NULL)
5498             {
5499                 pAuthGroup = &ParentDirectoryCB->ObjectInformation->Fcb->AuthGroup;
5500             }
5501             else if( DirectoryCB->ObjectInformation->Fcb != NULL)
5502             {
5503                 pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
5504             }
5505
5506             ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
5507                                               pAuthGroup,
5508                                               FALSE,
5509                                               &pDirEntry);
5510
5511             if( !NT_SUCCESS( ntStatus) ||
5512                 pDirEntry->TargetNameLength == 0)
5513             {
5514
5515                 if( pDirEntry != NULL)
5516                 {
5517
5518                     ntStatus = STATUS_ACCESS_DENIED;
5519                 }
5520
5521                 try_return( ntStatus);
5522             }
5523
5524             AFSAcquireExcl( &DirectoryCB->NonPaged->Lock,
5525                             TRUE);
5526
5527             if( DirectoryCB->NameInformation.TargetName.Length == 0)
5528             {
5529
5530                 //
5531                 // Update the target name
5532                 //
5533
5534                 ntStatus = AFSUpdateTargetName( &DirectoryCB->NameInformation.TargetName,
5535                                                 &DirectoryCB->Flags,
5536                                                 (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
5537                                                 (USHORT)pDirEntry->TargetNameLength);
5538
5539                 if( !NT_SUCCESS( ntStatus))
5540                 {
5541
5542                     AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5543
5544                     try_return( ntStatus);
5545                 }
5546             }
5547
5548             AFSConvertToShared( &DirectoryCB->NonPaged->Lock);
5549         }
5550
5551         //
5552         // Need to pass the full path in for parsing.
5553         //
5554
5555         if( AFSIsRelativeName( &DirectoryCB->NameInformation.TargetName))
5556         {
5557
5558             uniFullPathName.Length = 0;
5559             uniFullPathName.MaximumLength = ParentPathName->Length +
5560                                                     sizeof( WCHAR) +
5561                                                     DirectoryCB->NameInformation.TargetName.Length;
5562
5563             uniFullPathName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
5564                                                                         uniFullPathName.MaximumLength,
5565                                                                         AFS_NAME_BUFFER_SIX_TAG);
5566
5567             if( uniFullPathName.Buffer == NULL)
5568             {
5569
5570                 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5571
5572                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5573             }
5574
5575             pwchBuffer = uniFullPathName.Buffer;
5576
5577             RtlZeroMemory( uniFullPathName.Buffer,
5578                            uniFullPathName.MaximumLength);
5579
5580             RtlCopyMemory( uniFullPathName.Buffer,
5581                            ParentPathName->Buffer,
5582                            ParentPathName->Length);
5583
5584             uniFullPathName.Length = ParentPathName->Length;
5585
5586             if( uniFullPathName.Buffer[ (uniFullPathName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
5587                 DirectoryCB->NameInformation.TargetName.Buffer[ 0] != L'\\')
5588             {
5589
5590                 uniFullPathName.Buffer[ uniFullPathName.Length/sizeof( WCHAR)] = L'\\';
5591
5592                 uniFullPathName.Length += sizeof( WCHAR);
5593             }
5594
5595             RtlCopyMemory( &uniFullPathName.Buffer[ uniFullPathName.Length/sizeof( WCHAR)],
5596                            DirectoryCB->NameInformation.TargetName.Buffer,
5597                            DirectoryCB->NameInformation.TargetName.Length);
5598
5599             uniFullPathName.Length += DirectoryCB->NameInformation.TargetName.Length;
5600
5601             uniParsedName.Length = uniFullPathName.Length - ParentPathName->Length;
5602             uniParsedName.MaximumLength = uniParsedName.Length;
5603
5604             uniParsedName.Buffer = &uniFullPathName.Buffer[ ParentPathName->Length/sizeof( WCHAR)];
5605
5606             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5607
5608             //
5609             // We populate up to the current parent
5610             //
5611
5612             if( RelatedNameArray != NULL)
5613             {
5614
5615                 pNameArray = AFSInitNameArray( NULL,
5616                                                RelatedNameArray->MaxElementCount);
5617
5618                 if( pNameArray == NULL)
5619                 {
5620
5621                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5622                 }
5623
5624                 ntStatus = AFSPopulateNameArrayFromRelatedArray( pNameArray,
5625                                                                  RelatedNameArray,
5626                                                                  ParentDirectoryCB);
5627             }
5628             else
5629             {
5630
5631                 pNameArray = AFSInitNameArray( NULL,
5632                                                0);
5633
5634                 if( pNameArray == NULL)
5635                 {
5636
5637                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5638                 }
5639
5640                 ntStatus = AFSPopulateNameArray( pNameArray,
5641                                                  NULL,
5642                                                  ParentDirectoryCB);
5643             }
5644
5645             if( !NT_SUCCESS( ntStatus))
5646             {
5647
5648                 try_return( ntStatus);
5649             }
5650
5651             pVolumeCB = ParentDirectoryCB->ObjectInformation->VolumeCB;
5652
5653             AFSAcquireShared( pVolumeCB->VolumeLock,
5654                               TRUE);
5655
5656             pParentDirEntry = ParentDirectoryCB;
5657         }
5658         else
5659         {
5660
5661             uniFullPathName.Length = 0;
5662             uniFullPathName.MaximumLength = DirectoryCB->NameInformation.TargetName.Length;
5663
5664             uniFullPathName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
5665                                                                         uniFullPathName.MaximumLength,
5666                                                                         AFS_NAME_BUFFER_SEVEN_TAG);
5667
5668             if( uniFullPathName.Buffer == NULL)
5669             {
5670
5671                 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5672
5673                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5674             }
5675
5676             pwchBuffer = uniFullPathName.Buffer;
5677
5678             RtlZeroMemory( uniFullPathName.Buffer,
5679                            uniFullPathName.MaximumLength);
5680
5681             RtlCopyMemory( uniFullPathName.Buffer,
5682                            DirectoryCB->NameInformation.TargetName.Buffer,
5683                            DirectoryCB->NameInformation.TargetName.Length);
5684
5685             uniFullPathName.Length = DirectoryCB->NameInformation.TargetName.Length;
5686
5687             //
5688             // This name should begin with the \afs server so parse it off and check it
5689             //
5690
5691             FsRtlDissectName( uniFullPathName,
5692                               &uniComponentName,
5693                               &uniRemainingPath);
5694
5695             if( RtlCompareUnicodeString( &uniComponentName,
5696                                          &AFSServerName,
5697                                          TRUE) != 0)
5698             {
5699
5700                 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5701
5702                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
5703                               AFS_TRACE_LEVEL_ERROR,
5704                               "AFSRetrieveFileAttributes Name %wZ contains invalid server name\n",
5705                               &uniFullPathName);
5706
5707                 try_return( ntStatus = STATUS_OBJECT_PATH_INVALID);
5708             }
5709
5710             uniFullPathName = uniRemainingPath;
5711
5712             uniParsedName = uniFullPathName;
5713
5714             ulNameDifference = (ULONG)(uniFullPathName.Length > 0 ? ((char *)uniFullPathName.Buffer - (char *)pwchBuffer) : 0);
5715
5716             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
5717
5718             //
5719             // Our name array
5720             //
5721
5722             pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
5723                                            0);
5724
5725             if( pNameArray == NULL)
5726             {
5727
5728                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
5729             }
5730
5731             pVolumeCB = AFSGlobalRoot;
5732
5733             AFSAcquireShared( pVolumeCB->VolumeLock,
5734                               TRUE);
5735
5736             pParentDirEntry = AFSGlobalRoot->DirectoryCB;
5737         }
5738
5739         //
5740         // Increment the ref count on the volume and dir entry for correct processing below
5741         //
5742
5743         InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
5744
5745         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
5746                       AFS_TRACE_LEVEL_VERBOSE,
5747                       "AFSRetrieveFileAttributes Increment count on volume %08lX Cnt %d\n",
5748                       pVolumeCB,
5749                       pVolumeCB->VolumeReferenceCount);
5750
5751         InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
5752
5753         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5754                       AFS_TRACE_LEVEL_VERBOSE,
5755                       "AFSRetrieveFileAttributes Increment count on %wZ DE %p Ccb %p Cnt %d\n",
5756                       &pParentDirEntry->NameInformation.FileName,
5757                       pParentDirEntry,
5758                       NULL,
5759                       pParentDirEntry->OpenReferenceCount);
5760
5761         ntStatus = AFSLocateNameEntry( NULL,
5762                                        NULL,
5763                                        &uniFullPathName,
5764                                        &uniParsedName,
5765                                        pNameArray,
5766                                        AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL,
5767                                        &pVolumeCB,
5768                                        &pParentDirEntry,
5769                                        &pDirectoryEntry,
5770                                        NULL);
5771
5772         if( !NT_SUCCESS( ntStatus))
5773         {
5774
5775             //
5776             // The volume lock was released on failure above
5777             // Except for STATUS_OBJECT_NAME_NOT_FOUND
5778             //
5779
5780             if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
5781             {
5782
5783                 if( pVolumeCB != NULL)
5784                 {
5785
5786                     InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
5787
5788                     AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
5789                                   AFS_TRACE_LEVEL_VERBOSE,
5790                                   "AFSRetrieveFileAttributes Decrement count on volume %08lX Cnt %d\n",
5791                                   pVolumeCB,
5792                                   pVolumeCB->VolumeReferenceCount);
5793
5794                     AFSReleaseResource( pVolumeCB->VolumeLock);
5795                 }
5796
5797                 if( pDirectoryEntry != NULL)
5798                 {
5799
5800                     InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
5801
5802                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5803                                   AFS_TRACE_LEVEL_VERBOSE,
5804                                   "AFSRetrieveFileAttributes Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
5805                                   &pDirectoryEntry->NameInformation.FileName,
5806                                   pDirectoryEntry,
5807                                   NULL,
5808                                   pDirectoryEntry->OpenReferenceCount);
5809                 }
5810                 else
5811                 {
5812
5813                     InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
5814
5815                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5816                                   AFS_TRACE_LEVEL_VERBOSE,
5817                                   "AFSRetrieveFileAttributes Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
5818                                   &pParentDirEntry->NameInformation.FileName,
5819                                   pParentDirEntry,
5820                                   NULL,
5821                                   pParentDirEntry->OpenReferenceCount);
5822                 }
5823             }
5824
5825             pVolumeCB = NULL;
5826
5827             try_return( ntStatus);
5828         }
5829
5830         //
5831         // Store off the information
5832         //
5833
5834         FileInfo->FileAttributes = pDirectoryEntry->ObjectInformation->FileAttributes;
5835
5836         //
5837         // Check for the mount point being returned
5838         //
5839
5840         if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_MOUNTPOINT)
5841         {
5842
5843             FileInfo->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
5844         }
5845         else if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK ||
5846                  pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DFSLINK)
5847         {
5848
5849             FileInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
5850         }
5851
5852         FileInfo->AllocationSize = pDirectoryEntry->ObjectInformation->AllocationSize;
5853
5854         FileInfo->EndOfFile = pDirectoryEntry->ObjectInformation->EndOfFile;
5855
5856         FileInfo->CreationTime = pDirectoryEntry->ObjectInformation->CreationTime;
5857
5858         FileInfo->LastAccessTime = pDirectoryEntry->ObjectInformation->LastAccessTime;
5859
5860         FileInfo->LastWriteTime = pDirectoryEntry->ObjectInformation->LastWriteTime;
5861
5862         FileInfo->ChangeTime = pDirectoryEntry->ObjectInformation->ChangeTime;
5863
5864         //
5865         // Remove the reference made above
5866         //
5867
5868         InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
5869
5870         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
5871                       AFS_TRACE_LEVEL_VERBOSE,
5872                       "AFSRetrieveFileAttributes Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
5873                       &pDirectoryEntry->NameInformation.FileName,
5874                       pDirectoryEntry,
5875                       NULL,
5876                       pDirectoryEntry->OpenReferenceCount);
5877
5878 try_exit:
5879
5880         if( pDirEntry != NULL)
5881         {
5882
5883             AFSExFreePool( pDirEntry);
5884         }
5885
5886         if( pVolumeCB != NULL)
5887         {
5888
5889             InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
5890
5891             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
5892                           AFS_TRACE_LEVEL_VERBOSE,
5893                           "AFSRetrieveFileAttributes Decrement2 count on volume %08lX Cnt %d\n",
5894                           pVolumeCB,
5895                           pVolumeCB->VolumeReferenceCount);
5896
5897             AFSReleaseResource( pVolumeCB->VolumeLock);
5898         }
5899
5900         if( pNameArray != NULL)
5901         {
5902
5903             AFSFreeNameArray( pNameArray);
5904         }
5905
5906         if( pwchBuffer != NULL)
5907         {
5908
5909             //
5910             // Always free the buffer that we allocated as AFSLocateNameEntry
5911             // will not free it.  If uniFullPathName.Buffer was allocated by
5912             // AFSLocateNameEntry, then we must free that as well.
5913             // Check that the uniFullPathName.Buffer in the string is not the same
5914             // offset by the length of the server name
5915             //
5916
5917             if( uniFullPathName.Length > 0 &&
5918                 pwchBuffer != (WCHAR *)((char *)uniFullPathName.Buffer - ulNameDifference))
5919             {
5920
5921                 AFSExFreePool( uniFullPathName.Buffer);
5922             }
5923
5924             AFSExFreePool( pwchBuffer);
5925         }
5926     }
5927
5928     return ntStatus;
5929 }
5930
5931 AFSObjectInfoCB *
5932 AFSAllocateObjectInfo( IN AFSObjectInfoCB *ParentObjectInfo,
5933                        IN ULONGLONG HashIndex)
5934 {
5935
5936     NTSTATUS ntStatus = STATUS_SUCCESS;
5937     AFSObjectInfoCB *pObjectInfo = NULL;
5938
5939     __Enter
5940     {
5941
5942         pObjectInfo = (AFSObjectInfoCB *)AFSExAllocatePoolWithTag( PagedPool,
5943                                                                    sizeof( AFSObjectInfoCB),
5944                                                                    AFS_OBJECT_INFO_TAG);
5945
5946         if( pObjectInfo == NULL)
5947         {
5948
5949             try_return( pObjectInfo);
5950         }
5951
5952         RtlZeroMemory( pObjectInfo,
5953                        sizeof( AFSObjectInfoCB));
5954
5955         pObjectInfo->NonPagedInfo = (AFSNonPagedObjectInfoCB *)AFSExAllocatePoolWithTag( NonPagedPool,
5956                                                                                          sizeof( AFSNonPagedObjectInfoCB),
5957                                                                                          AFS_NP_OBJECT_INFO_TAG);
5958
5959         if( pObjectInfo->NonPagedInfo == NULL)
5960         {
5961
5962             AFSExFreePool( pObjectInfo);
5963
5964             try_return( pObjectInfo = NULL);
5965         }
5966
5967         ExInitializeResourceLite( &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock);
5968
5969         pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock = &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock;
5970
5971         pObjectInfo->VolumeCB = ParentObjectInfo->VolumeCB;
5972
5973         pObjectInfo->ParentObjectInformation = ParentObjectInfo;
5974
5975         if( ParentObjectInfo != NULL)
5976         {
5977             InterlockedIncrement( &ParentObjectInfo->ObjectReferenceCount);
5978         }
5979
5980         //
5981         // Initialize the access time
5982         //
5983
5984         KeQueryTickCount( &pObjectInfo->LastAccessCount);
5985
5986         if( HashIndex != 0)
5987         {
5988
5989             //
5990             // Insert the entry into the object tree and list
5991             //
5992
5993             pObjectInfo->TreeEntry.HashIndex = HashIndex;
5994
5995             if( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeHead == NULL)
5996             {
5997
5998                 ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeHead = &pObjectInfo->TreeEntry;
5999             }
6000             else
6001             {
6002
6003                 ntStatus = AFSInsertHashEntry( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
6004                                                &pObjectInfo->TreeEntry);
6005
6006                 ASSERT( NT_SUCCESS( ntStatus));
6007             }
6008
6009             //
6010             // And the object list in the volume
6011             //
6012
6013             if( ParentObjectInfo->VolumeCB->ObjectInfoListHead == NULL)
6014             {
6015
6016                 ParentObjectInfo->VolumeCB->ObjectInfoListHead = pObjectInfo;
6017             }
6018             else
6019             {
6020
6021                 ParentObjectInfo->VolumeCB->ObjectInfoListTail->ListEntry.fLink = (void *)pObjectInfo;
6022
6023                 pObjectInfo->ListEntry.bLink = (void *)ParentObjectInfo->VolumeCB->ObjectInfoListTail;
6024             }
6025
6026             ParentObjectInfo->VolumeCB->ObjectInfoListTail = pObjectInfo;
6027
6028             //
6029             // Indicate the object is in the hash tree and linked list in the volume
6030             //
6031
6032             SetFlag( pObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE | AFS_OBJECT_INSERTED_VOLUME_LIST);
6033         }
6034
6035 try_exit:
6036
6037         NOTHING;
6038     }
6039
6040     return pObjectInfo;
6041 }
6042
6043 void
6044 AFSDeleteObjectInfo( IN AFSObjectInfoCB *ObjectInfo)
6045 {
6046
6047     BOOLEAN bAcquiredTreeLock = FALSE;
6048
6049     if( !ExIsResourceAcquiredExclusiveLite( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock))
6050     {
6051
6052         ASSERT( !ExIsResourceAcquiredLite( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock));
6053
6054         AFSAcquireExcl( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
6055                         TRUE);
6056
6057         bAcquiredTreeLock = TRUE;
6058     }
6059
6060     //
6061     // Remove it from the tree and list if it was inserted
6062     //
6063
6064     if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
6065     {
6066
6067         AFSRemoveHashEntry( &ObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
6068                             &ObjectInfo->TreeEntry);
6069     }
6070
6071     if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_INSERTED_VOLUME_LIST))
6072     {
6073
6074         if( ObjectInfo->ListEntry.fLink == NULL)
6075         {
6076
6077             ObjectInfo->VolumeCB->ObjectInfoListTail = (AFSObjectInfoCB *)ObjectInfo->ListEntry.bLink;
6078
6079             if( ObjectInfo->VolumeCB->ObjectInfoListTail != NULL)
6080             {
6081
6082                 ObjectInfo->VolumeCB->ObjectInfoListTail->ListEntry.fLink = NULL;
6083             }
6084         }
6085         else
6086         {
6087
6088             ((AFSObjectInfoCB *)(ObjectInfo->ListEntry.fLink))->ListEntry.bLink = ObjectInfo->ListEntry.bLink;
6089         }
6090
6091         if( ObjectInfo->ListEntry.bLink == NULL)
6092         {
6093
6094             ObjectInfo->VolumeCB->ObjectInfoListHead = (AFSObjectInfoCB *)ObjectInfo->ListEntry.fLink;
6095
6096             if( ObjectInfo->VolumeCB->ObjectInfoListHead != NULL)
6097             {
6098
6099                 ObjectInfo->VolumeCB->ObjectInfoListHead->ListEntry.bLink = NULL;
6100             }
6101         }
6102         else
6103         {
6104
6105             ((AFSObjectInfoCB *)(ObjectInfo->ListEntry.bLink))->ListEntry.fLink = ObjectInfo->ListEntry.fLink;
6106         }
6107     }
6108
6109     if( ObjectInfo->ParentObjectInformation != NULL)
6110     {
6111         InterlockedDecrement( &ObjectInfo->ParentObjectInformation->ObjectReferenceCount);
6112     }
6113
6114     if( bAcquiredTreeLock)
6115     {
6116
6117         AFSReleaseResource( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
6118     }
6119
6120     //
6121     // Release the fid in the service
6122     //
6123
6124     if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE))
6125     {
6126
6127         AFSReleaseFid( &ObjectInfo->FileId);
6128     }
6129
6130     ExDeleteResourceLite( &ObjectInfo->NonPagedInfo->DirectoryNodeHdrLock);
6131
6132     AFSExFreePool( ObjectInfo->NonPagedInfo);
6133
6134     AFSExFreePool( ObjectInfo);
6135
6136     return;
6137 }
6138
6139 NTSTATUS
6140 AFSEvaluateRootEntry( IN AFSDirectoryCB *DirectoryCB,
6141                       OUT AFSDirectoryCB **TargetDirEntry)
6142 {
6143
6144     NTSTATUS ntStatus = STATUS_SUCCESS;
6145     AFSDirEnumEntry *pDirEntry = NULL, *pLastDirEntry = NULL;
6146     UNICODE_STRING uniFullPathName;
6147     AFSNameArrayHdr    *pNameArray = NULL;
6148     AFSVolumeCB *pVolumeCB = NULL;
6149     AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
6150     WCHAR *pwchBuffer = NULL;
6151     UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
6152     ULONG ulNameDifference = 0;
6153     GUID *pAuthGroup = NULL;
6154
6155     __Enter
6156     {
6157
6158         //
6159         // Retrieve a target name for the entry
6160         //
6161
6162         AFSAcquireShared( &DirectoryCB->NonPaged->Lock,
6163                           TRUE);
6164
6165         if( DirectoryCB->NameInformation.TargetName.Length == 0)
6166         {
6167
6168             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
6169
6170             if( DirectoryCB->ObjectInformation->Fcb != NULL)
6171             {
6172                 pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
6173             }
6174
6175             ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
6176                                               pAuthGroup,
6177                                               FALSE,
6178                                               &pDirEntry);
6179
6180             if( !NT_SUCCESS( ntStatus) ||
6181                 pDirEntry->TargetNameLength == 0)
6182             {
6183
6184                 if( pDirEntry != NULL)
6185                 {
6186
6187                     ntStatus = STATUS_ACCESS_DENIED;
6188                 }
6189
6190                 try_return( ntStatus);
6191             }
6192
6193             AFSAcquireExcl( &DirectoryCB->NonPaged->Lock,
6194                             TRUE);
6195
6196             if( DirectoryCB->NameInformation.TargetName.Length == 0)
6197             {
6198
6199                 //
6200                 // Update the target name
6201                 //
6202
6203                 ntStatus = AFSUpdateTargetName( &DirectoryCB->NameInformation.TargetName,
6204                                                 &DirectoryCB->Flags,
6205                                                 (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
6206                                                 (USHORT)pDirEntry->TargetNameLength);
6207
6208                 if( !NT_SUCCESS( ntStatus))
6209                 {
6210
6211                     AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
6212
6213                     try_return( ntStatus);
6214                 }
6215             }
6216
6217             AFSConvertToShared( &DirectoryCB->NonPaged->Lock);
6218         }
6219
6220         //
6221         // Need to pass the full path in for parsing.
6222         //
6223
6224         uniFullPathName.Length = 0;
6225         uniFullPathName.MaximumLength = DirectoryCB->NameInformation.TargetName.Length;
6226
6227         uniFullPathName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
6228                                                                     uniFullPathName.MaximumLength,
6229                                                                     AFS_NAME_BUFFER_EIGHT_TAG);
6230
6231         if( uniFullPathName.Buffer == NULL)
6232         {
6233
6234             AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
6235
6236             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
6237         }
6238
6239         pwchBuffer = uniFullPathName.Buffer;
6240
6241         RtlZeroMemory( uniFullPathName.Buffer,
6242                        uniFullPathName.MaximumLength);
6243
6244         RtlCopyMemory( uniFullPathName.Buffer,
6245                        DirectoryCB->NameInformation.TargetName.Buffer,
6246                        DirectoryCB->NameInformation.TargetName.Length);
6247
6248         uniFullPathName.Length = DirectoryCB->NameInformation.TargetName.Length;
6249
6250         //
6251         // This name should begin with the \afs server so parse it off and chech it
6252         //
6253
6254         FsRtlDissectName( uniFullPathName,
6255                           &uniComponentName,
6256                           &uniRemainingPath);
6257
6258         if( RtlCompareUnicodeString( &uniComponentName,
6259                                      &AFSServerName,
6260                                      TRUE) != 0)
6261         {
6262
6263             //
6264             // Try evaluating the full path
6265             //
6266
6267             uniFullPathName.Buffer = pwchBuffer;
6268
6269             uniFullPathName.Length = DirectoryCB->NameInformation.TargetName.Length;
6270
6271             uniFullPathName.MaximumLength = uniFullPathName.Length;
6272         }
6273         else
6274         {
6275
6276             uniFullPathName = uniRemainingPath;
6277         }
6278
6279         uniParsedName = uniFullPathName;
6280
6281         ulNameDifference = (ULONG)(uniFullPathName.Length > 0 ? ((char *)uniFullPathName.Buffer - (char *)pwchBuffer) : 0);
6282
6283         AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
6284
6285         //
6286         // Our name array
6287         //
6288
6289         pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
6290                                        0);
6291
6292         if( pNameArray == NULL)
6293         {
6294
6295             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
6296         }
6297
6298         pVolumeCB = AFSGlobalRoot;
6299
6300         AFSAcquireShared( pVolumeCB->VolumeLock,
6301                           TRUE);
6302
6303         pParentDirEntry = AFSGlobalRoot->DirectoryCB;
6304
6305         InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
6306
6307         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
6308                       AFS_TRACE_LEVEL_VERBOSE,
6309                       "AFSEvaluateRootEntry Increment count on volume %08lX Cnt %d\n",
6310                       pVolumeCB,
6311                       pVolumeCB->VolumeReferenceCount);
6312
6313         InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
6314
6315         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
6316                       AFS_TRACE_LEVEL_VERBOSE,
6317                       "AFSEvaluateRootEntry Increment count on %wZ DE %p Ccb %p Cnt %d\n",
6318                       &pParentDirEntry->NameInformation.FileName,
6319                       pParentDirEntry,
6320                       NULL,
6321                       pParentDirEntry->OpenReferenceCount);
6322
6323         ntStatus = AFSLocateNameEntry( NULL,
6324                                        NULL,
6325                                        &uniFullPathName,
6326                                        &uniParsedName,
6327                                        pNameArray,
6328                                        0,
6329                                        &pVolumeCB,
6330                                        &pParentDirEntry,
6331                                        &pDirectoryEntry,
6332                                        NULL);
6333
6334         if( !NT_SUCCESS( ntStatus))
6335         {
6336
6337             //
6338             // The volume lock was released on failure above
6339             // Except for STATUS_OBJECT_NAME_NOT_FOUND
6340             //
6341
6342             if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
6343             {
6344
6345                 if( pVolumeCB != NULL)
6346                 {
6347
6348                     InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
6349
6350                     AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
6351                                   AFS_TRACE_LEVEL_VERBOSE,
6352                                   "AFSEvaluateRootEntry Decrement count on volume %08lX Cnt %d\n",
6353                                   pVolumeCB,
6354                                   pVolumeCB->VolumeReferenceCount);
6355
6356                     AFSReleaseResource( pVolumeCB->VolumeLock);
6357                 }
6358
6359                 if( pDirectoryEntry != NULL)
6360                 {
6361
6362                     InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
6363
6364                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
6365                                   AFS_TRACE_LEVEL_VERBOSE,
6366                                   "AFSEvaluateRootEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
6367                                   &pDirectoryEntry->NameInformation.FileName,
6368                                   pDirectoryEntry,
6369                                   NULL,
6370                                   pDirectoryEntry->OpenReferenceCount);
6371                 }
6372                 else
6373                 {
6374
6375                     InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
6376
6377                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
6378                                   AFS_TRACE_LEVEL_VERBOSE,
6379                                   "AFSEvaluateRootEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
6380                                   &pParentDirEntry->NameInformation.FileName,
6381                                   pParentDirEntry,
6382                                   NULL,
6383                                   pParentDirEntry->OpenReferenceCount);
6384                 }
6385             }
6386
6387             pVolumeCB = NULL;
6388
6389             try_return( ntStatus);
6390         }
6391
6392         //
6393         // Pass back the target dir entry for this request
6394         //
6395
6396         *TargetDirEntry = pDirectoryEntry;
6397
6398 try_exit:
6399
6400         if( pDirEntry != NULL)
6401         {
6402
6403             AFSExFreePool( pDirEntry);
6404         }
6405
6406         if( pVolumeCB != NULL)
6407         {
6408
6409             InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
6410
6411             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
6412                           AFS_TRACE_LEVEL_VERBOSE,
6413                           "AFSEvaluateRootEntry2 Decrement count on volume %08lX Cnt %d\n",
6414                           pVolumeCB,
6415                           pVolumeCB->VolumeReferenceCount);
6416
6417             AFSReleaseResource( pVolumeCB->VolumeLock);
6418         }
6419
6420         if( pNameArray != NULL)
6421         {
6422
6423             AFSFreeNameArray( pNameArray);
6424         }
6425
6426         if( pwchBuffer != NULL)
6427         {
6428
6429             //
6430             // Always free the buffer that we allocated as AFSLocateNameEntry
6431             // will not free it.  If uniFullPathName.Buffer was allocated by
6432             // AFSLocateNameEntry, then we must free that as well.
6433             // Check that the uniFullPathName.Buffer in the string is not the same
6434             // offset by the length of the server name
6435             //
6436
6437             if( uniFullPathName.Length > 0 &&
6438                 pwchBuffer != (WCHAR *)((char *)uniFullPathName.Buffer - ulNameDifference))
6439             {
6440
6441                 AFSExFreePool( uniFullPathName.Buffer);
6442             }
6443
6444             AFSExFreePool( pwchBuffer);
6445         }
6446     }
6447
6448     return ntStatus;
6449 }
6450
6451 NTSTATUS
6452 AFSCleanupFcb( IN AFSFcb *Fcb,
6453                IN BOOLEAN ForceFlush)
6454 {
6455
6456     NTSTATUS ntStatus = STATUS_SUCCESS;
6457     AFSDeviceExt *pRDRDeviceExt = NULL, *pControlDeviceExt = NULL;
6458     LARGE_INTEGER liTime;
6459     IO_STATUS_BLOCK stIoStatus;
6460
6461     __Enter
6462     {
6463
6464         pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
6465
6466         pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
6467
6468         if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
6469         {
6470
6471             if( !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) &&
6472                 !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
6473             {
6474
6475                 AFSAcquireExcl( &Fcb->NPFcb->Resource,
6476                                 TRUE);
6477
6478                 if( Fcb->OpenReferenceCount > 0)
6479                 {
6480
6481                     __try
6482                     {
6483
6484                         CcFlushCache( &Fcb->NPFcb->SectionObjectPointers,
6485                                       NULL,
6486                                       0,
6487                                       &stIoStatus);
6488
6489                         if( !NT_SUCCESS( stIoStatus.Status))
6490                         {
6491
6492                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
6493                                           AFS_TRACE_LEVEL_ERROR,
6494                                           "AFSCleanupFcb CcFlushCache [1] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
6495                                           Fcb->ObjectInformation->FileId.Cell,
6496                                           Fcb->ObjectInformation->FileId.Volume,
6497                                           Fcb->ObjectInformation->FileId.Vnode,
6498                                           Fcb->ObjectInformation->FileId.Unique,
6499                                           stIoStatus.Status,
6500                                           stIoStatus.Information);
6501
6502                             ntStatus = stIoStatus.Status;
6503                         }
6504
6505                         CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
6506                                              NULL,
6507                                              0,
6508                                              FALSE);
6509                     }
6510                     __except( EXCEPTION_EXECUTE_HANDLER)
6511                     {
6512                         ntStatus = GetExceptionCode();
6513                     }
6514                 }
6515
6516                 AFSReleaseResource( &Fcb->NPFcb->Resource);
6517
6518                 //
6519                 // Wait for any currently running flush or release requests to complete
6520                 //
6521
6522                 AFSWaitOnQueuedFlushes( Fcb);
6523
6524                 //
6525                 // Now perform another flush on the file
6526                 //
6527
6528                 if( !NT_SUCCESS( AFSFlushExtents( Fcb)))
6529                 {
6530
6531                     AFSReleaseExtentsWithFlush( Fcb);
6532                 }
6533             }
6534
6535             if( Fcb->OpenReferenceCount == 0 ||
6536                 BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
6537                 BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
6538             {
6539
6540                 AFSTearDownFcbExtents( Fcb);
6541             }
6542
6543             try_return( ntStatus);
6544         }
6545
6546         KeQueryTickCount( &liTime);
6547
6548         //
6549         // First up are there dirty extents in the cache to flush?
6550         //
6551
6552         if( ForceFlush ||
6553             ( !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) &&
6554               !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
6555               ( Fcb->Specific.File.ExtentsDirtyCount ||
6556                 Fcb->Specific.File.ExtentCount) &&
6557               (liTime.QuadPart - Fcb->Specific.File.LastServerFlush.QuadPart)
6558                                                     >= pControlDeviceExt->Specific.Control.FcbFlushTimeCount.QuadPart))
6559         {
6560
6561             if( !NT_SUCCESS( AFSFlushExtents( Fcb)) &&
6562                 Fcb->OpenReferenceCount == 0)
6563             {
6564
6565                 AFSReleaseExtentsWithFlush( Fcb);
6566             }
6567         }
6568         else if( BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
6569                  BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
6570         {
6571
6572             //
6573             // The file has been marked as invalid.  Dump it
6574             //
6575
6576             AFSTearDownFcbExtents( Fcb);
6577         }
6578
6579         //
6580         // If there are extents and they haven't been used recently *and*
6581         // are not being used
6582         //
6583
6584         if( ( ForceFlush ||
6585               ( 0 != Fcb->Specific.File.ExtentCount &&
6586                 0 != Fcb->Specific.File.LastExtentAccess.QuadPart &&
6587                 (liTime.QuadPart - Fcb->Specific.File.LastExtentAccess.QuadPart) >=
6588                                         (AFS_SERVER_PURGE_SLEEP * pControlDeviceExt->Specific.Control.FcbPurgeTimeCount.QuadPart))) &&
6589             AFSAcquireExcl( &Fcb->NPFcb->Resource,
6590                             ForceFlush))
6591         {
6592
6593             __try
6594             {
6595
6596                 CcFlushCache( &Fcb->NPFcb->SectionObjectPointers,
6597                               NULL,
6598                               0,
6599                               &stIoStatus);
6600
6601                 if( !NT_SUCCESS( stIoStatus.Status))
6602                 {
6603
6604                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
6605                                   AFS_TRACE_LEVEL_ERROR,
6606                                   "AFSCleanupFcb CcFlushCache [2] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
6607                                   Fcb->ObjectInformation->FileId.Cell,
6608                                   Fcb->ObjectInformation->FileId.Volume,
6609                                   Fcb->ObjectInformation->FileId.Vnode,
6610                                   Fcb->ObjectInformation->FileId.Unique,
6611                                   stIoStatus.Status,
6612                                   stIoStatus.Information);
6613
6614                     ntStatus = stIoStatus.Status;
6615                 }
6616
6617                 if( ForceFlush)
6618                 {
6619
6620                     CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
6621                                          NULL,
6622                                          0,
6623                                          FALSE);
6624                 }
6625             }
6626             __except( EXCEPTION_EXECUTE_HANDLER)
6627             {
6628                 ntStatus = GetExceptionCode();
6629             }
6630
6631             AFSReleaseResource( &Fcb->NPFcb->Resource);
6632
6633             if( Fcb->OpenReferenceCount == 0)
6634             {
6635
6636                 //
6637                 // Tear em down we'll not be needing them again
6638                 //
6639
6640                 AFSTearDownFcbExtents( Fcb);
6641             }
6642         }
6643
6644 try_exit:
6645
6646         NOTHING;
6647     }
6648
6649     return ntStatus;
6650 }
6651
6652 NTSTATUS
6653 AFSUpdateDirEntryName( IN AFSDirectoryCB *DirectoryCB,
6654                        IN UNICODE_STRING *NewFileName)
6655 {
6656
6657     NTSTATUS ntStatus = STATUS_SUCCESS;
6658     WCHAR *pTmpBuffer = NULL;
6659
6660     __Enter
6661     {
6662
6663         if( NewFileName->Length > DirectoryCB->NameInformation.FileName.Length)
6664         {
6665
6666             if( BooleanFlagOn( DirectoryCB->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
6667             {
6668
6669                 AFSExFreePool( DirectoryCB->NameInformation.FileName.Buffer);
6670
6671                 ClearFlag( DirectoryCB->Flags, AFS_DIR_RELEASE_NAME_BUFFER);
6672
6673                 DirectoryCB->NameInformation.FileName.Buffer = NULL;
6674             }
6675
6676             //
6677             // OK, we need to allocate a new name buffer
6678             //
6679
6680             pTmpBuffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
6681                                                             NewFileName->Length,
6682                                                             AFS_NAME_BUFFER_NINE_TAG);
6683
6684             if( pTmpBuffer == NULL)
6685             {
6686
6687                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
6688             }
6689
6690             DirectoryCB->NameInformation.FileName.Buffer = pTmpBuffer;
6691
6692             DirectoryCB->NameInformation.FileName.MaximumLength = NewFileName->Length;
6693
6694             SetFlag( DirectoryCB->Flags, AFS_DIR_RELEASE_NAME_BUFFER);
6695         }
6696
6697         DirectoryCB->NameInformation.FileName.Length = NewFileName->Length;
6698
6699         RtlCopyMemory( DirectoryCB->NameInformation.FileName.Buffer,
6700                        NewFileName->Buffer,
6701                        NewFileName->Length);
6702
6703 try_exit:
6704
6705         NOTHING;
6706     }
6707
6708     return ntStatus;
6709 }
6710
6711 NTSTATUS
6712 AFSReadCacheFile( IN void *ReadBuffer,
6713                   IN LARGE_INTEGER *ReadOffset,
6714                   IN ULONG RequestedDataLength,
6715                   IN OUT PULONG BytesRead)
6716 {
6717
6718     NTSTATUS            ntStatus = STATUS_SUCCESS;
6719     PIRP                pIrp = NULL;
6720     KEVENT              kEvent;
6721     PIO_STACK_LOCATION  pIoStackLocation = NULL;
6722     AFSDeviceExt       *pRdrDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
6723     DEVICE_OBJECT      *pTargetDeviceObject = NULL;
6724     FILE_OBJECT        *pCacheFileObject = NULL;
6725
6726     __Enter
6727     {
6728
6729         pCacheFileObject = AFSReferenceCacheFileObject();
6730
6731         if( pCacheFileObject == NULL)
6732         {
6733             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
6734         }
6735
6736         pTargetDeviceObject = IoGetRelatedDeviceObject( pCacheFileObject);
6737
6738         //
6739         // Initialize the event
6740         //
6741
6742         KeInitializeEvent( &kEvent,
6743                            SynchronizationEvent,
6744                            FALSE);
6745
6746         //
6747         // Allocate an irp for this request.  This could also come from a
6748         // private pool, for instance.
6749         //
6750
6751         pIrp = IoAllocateIrp( pTargetDeviceObject->StackSize,
6752                               FALSE);
6753
6754         if( pIrp == NULL)
6755         {
6756
6757             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
6758         }
6759
6760         //
6761         // Build the IRP's main body
6762         //
6763
6764         pIrp->UserBuffer = ReadBuffer;
6765
6766         pIrp->Tail.Overlay.Thread = PsGetCurrentThread();
6767         pIrp->RequestorMode = KernelMode;
6768         pIrp->Flags |= IRP_READ_OPERATION;
6769
6770         //
6771         // Set up the I/O stack location.
6772         //
6773
6774         pIoStackLocation = IoGetNextIrpStackLocation( pIrp);
6775         pIoStackLocation->MajorFunction = IRP_MJ_READ;
6776         pIoStackLocation->DeviceObject = pTargetDeviceObject;
6777         pIoStackLocation->FileObject = pCacheFileObject;
6778         pIoStackLocation->Parameters.Read.Length = RequestedDataLength;
6779
6780         pIoStackLocation->Parameters.Read.ByteOffset.QuadPart = ReadOffset->QuadPart;
6781
6782         //
6783         // Set the completion routine.
6784         //
6785
6786         IoSetCompletionRoutine( pIrp,
6787                                 AFSIrpComplete,
6788                                 &kEvent,
6789                                 TRUE,
6790                                 TRUE,
6791                                 TRUE);
6792
6793         //
6794         // Send it to the FSD
6795         //
6796
6797         ntStatus = IoCallDriver( pTargetDeviceObject,
6798                                  pIrp);
6799
6800         if( NT_SUCCESS( ntStatus))
6801         {
6802
6803             //
6804             // Wait for the I/O
6805             //
6806
6807             ntStatus = KeWaitForSingleObject( &kEvent,
6808                                               Executive,
6809                                               KernelMode,
6810                                               FALSE,
6811                                               0);
6812
6813             if( NT_SUCCESS( ntStatus))
6814             {
6815
6816                 ntStatus = pIrp->IoStatus.Status;
6817
6818                 *BytesRead = (ULONG)pIrp->IoStatus.Information;
6819             }
6820         }
6821
6822 try_exit:
6823
6824         if( pCacheFileObject != NULL)
6825         {
6826             AFSReleaseCacheFileObject( pCacheFileObject);
6827         }
6828
6829         if( pIrp != NULL)
6830         {
6831
6832             if( pIrp->MdlAddress != NULL)
6833             {
6834
6835                 if( FlagOn( pIrp->MdlAddress->MdlFlags, MDL_PAGES_LOCKED))
6836                 {
6837
6838                     MmUnlockPages( pIrp->MdlAddress);
6839                 }
6840
6841                 IoFreeMdl( pIrp->MdlAddress);
6842             }
6843
6844             pIrp->MdlAddress = NULL;
6845
6846             //
6847             // Free the Irp
6848             //
6849
6850             IoFreeIrp( pIrp);
6851         }
6852     }
6853
6854     return ntStatus;
6855 }
6856
6857 NTSTATUS
6858 AFSIrpComplete( IN PDEVICE_OBJECT DeviceObject,
6859                 IN PIRP           Irp,
6860                 IN PVOID          Context)
6861 {
6862
6863     KEVENT *pEvent = (KEVENT *)Context;
6864
6865     KeSetEvent( pEvent,
6866                 0,
6867                 FALSE);
6868
6869     return STATUS_MORE_PROCESSING_REQUIRED;
6870 }
6871
6872 BOOLEAN
6873 AFSIsDirectoryEmptyForDelete( IN AFSFcb *Fcb)
6874 {
6875
6876     BOOLEAN bIsEmpty = FALSE;
6877     AFSDirectoryCB *pDirEntry = NULL;
6878
6879     __Enter
6880     {
6881
6882         AFSAcquireShared( Fcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
6883                           TRUE);
6884
6885         bIsEmpty = TRUE;
6886
6887         if( Fcb->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
6888         {
6889
6890             pDirEntry = Fcb->ObjectInformation->Specific.Directory.DirectoryNodeListHead;
6891
6892             while( pDirEntry != NULL)
6893             {
6894
6895                 if( !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_FAKE) &&
6896                     !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED))
6897                 {
6898
6899                     bIsEmpty = FALSE;
6900
6901                     break;
6902                 }
6903
6904                 pDirEntry = (AFSDirectoryCB *)pDirEntry->ListEntry.fLink;
6905             }
6906
6907         }
6908
6909         AFSReleaseResource( Fcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
6910     }
6911
6912     return bIsEmpty;
6913 }
6914
6915 void
6916 AFSRemoveNameEntry( IN AFSObjectInfoCB *ParentObjectInfo,
6917                     IN AFSDirectoryCB *DirEntry)
6918 {
6919
6920     NTSTATUS ntStatus = STATUS_SUCCESS;
6921
6922     __Enter
6923     {
6924
6925         if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
6926         {
6927
6928             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
6929                           AFS_TRACE_LEVEL_VERBOSE,
6930                           "AFSRemoveNameEntry DE %p for %wZ has NOT_IN flag set\n",
6931                           DirEntry,
6932                           &DirEntry->NameInformation.FileName);
6933
6934             try_return( ntStatus);
6935         }
6936
6937         ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
6938
6939         //
6940         // Remove the entry from the parent tree
6941         //
6942
6943         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
6944                       AFS_TRACE_LEVEL_VERBOSE,
6945                       "AFSRemoveNameEntry DE %p for %wZ removing from case sensitive tree\n",
6946                       DirEntry,
6947                       &DirEntry->NameInformation.FileName);
6948
6949         AFSRemoveCaseSensitiveDirEntry( &ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
6950                                         DirEntry);
6951
6952         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
6953                       AFS_TRACE_LEVEL_VERBOSE,
6954                       "AFSRemoveNameEntry DE %p for %wZ removing from case insensitive tree\n",
6955                       DirEntry,
6956                       &DirEntry->NameInformation.FileName);
6957
6958         AFSRemoveCaseInsensitiveDirEntry( &ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
6959                                           DirEntry);
6960
6961         if( ParentObjectInfo->Specific.Directory.ShortNameTree &&
6962             DirEntry->Type.Data.ShortNameTreeEntry.HashIndex != 0)
6963         {
6964
6965             //
6966             // From the short name tree
6967             //
6968
6969             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
6970                           AFS_TRACE_LEVEL_VERBOSE,
6971                           "AFSRemoveNameEntry DE %p for %wZ removing from shortname tree\n",
6972                           DirEntry,
6973                           &DirEntry->NameInformation.FileName);
6974
6975             AFSRemoveShortNameDirEntry( &ParentObjectInfo->Specific.Directory.ShortNameTree,
6976                                         DirEntry);
6977         }
6978
6979         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
6980                       AFS_TRACE_LEVEL_VERBOSE,
6981                       "AFSRemoveNameEntry DE %p for %wZ setting NOT_IN flag\n",
6982                       DirEntry,
6983                       &DirEntry->NameInformation.FileName);
6984
6985         SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
6986
6987 try_exit:
6988
6989         NOTHING;
6990     }
6991
6992     return;
6993 }
6994
6995 LARGE_INTEGER
6996 AFSGetAuthenticationId()
6997 {
6998
6999     LARGE_INTEGER liAuthId = {0,0};
7000     NTSTATUS ntStatus = STATUS_SUCCESS;
7001     PACCESS_TOKEN hToken = NULL;
7002     PTOKEN_STATISTICS pTokenInfo = NULL;
7003     BOOLEAN bCopyOnOpen = FALSE;
7004     BOOLEAN bEffectiveOnly = FALSE;
7005     BOOLEAN bPrimaryToken = FALSE;
7006     SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
7007
7008     __Enter
7009     {
7010
7011         hToken = PsReferenceImpersonationToken( PsGetCurrentThread(),
7012                                                 &bCopyOnOpen,
7013                                                 &bEffectiveOnly,
7014                                                 &stImpersonationLevel);
7015
7016         if( hToken == NULL)
7017         {
7018
7019             hToken = PsReferencePrimaryToken( PsGetCurrentProcess());
7020
7021             if( hToken == NULL)
7022             {
7023
7024                 AFSDbgLogMsg( AFS_SUBSYSTEM_NETWORK_PROVIDER,
7025                               AFS_TRACE_LEVEL_ERROR,
7026                               "AFSGetAuthenticationId Failed to retrieve impersonation or primary token\n");
7027
7028                 try_return( ntStatus);
7029             }
7030
7031             bPrimaryToken = TRUE;
7032         }
7033
7034         ntStatus = SeQueryInformationToken( hToken,
7035                                             TokenStatistics,
7036                                             (PVOID *)&pTokenInfo);
7037
7038         if( !NT_SUCCESS( ntStatus))
7039         {
7040
7041             AFSDbgLogMsg( AFS_SUBSYSTEM_NETWORK_PROVIDER,
7042                           AFS_TRACE_LEVEL_ERROR,
7043                           "AFSGetAuthenticationId Failed to retrieve information Status %08lX\n", ntStatus);
7044
7045             try_return( ntStatus);
7046         }
7047
7048         liAuthId.HighPart = pTokenInfo->AuthenticationId.HighPart;
7049         liAuthId.LowPart = pTokenInfo->AuthenticationId.LowPart;
7050
7051         AFSDbgLogMsg( AFS_SUBSYSTEM_NETWORK_PROVIDER,
7052                       AFS_TRACE_LEVEL_VERBOSE,
7053                       "AFSGetAuthenticationId Successfully retrieved authentication ID %I64X\n",
7054                       liAuthId.QuadPart);
7055
7056 try_exit:
7057
7058         if( hToken != NULL)
7059         {
7060
7061             if( !bPrimaryToken)
7062             {
7063
7064                 PsDereferenceImpersonationToken( hToken);
7065             }
7066             else
7067             {
7068
7069                 PsDereferencePrimaryToken( hToken);
7070             }
7071         }
7072
7073         if( pTokenInfo != NULL)
7074         {
7075
7076             AFSExFreePool( pTokenInfo);
7077         }
7078     }
7079
7080     return liAuthId;
7081 }
7082
7083 void
7084 AFSUnwindFileInfo( IN AFSFcb *Fcb,
7085                    IN AFSCcb *Ccb)
7086 {
7087
7088     if( Ccb->FileUnwindInfo.FileAttributes != (ULONG)-1)
7089     {
7090         Ccb->DirectoryCB->ObjectInformation->FileAttributes = Ccb->FileUnwindInfo.FileAttributes;
7091     }
7092
7093     if( Ccb->FileUnwindInfo.CreationTime.QuadPart != (ULONGLONG)-1)
7094     {
7095         Ccb->DirectoryCB->ObjectInformation->CreationTime.QuadPart = Ccb->FileUnwindInfo.CreationTime.QuadPart;
7096     }
7097
7098     if( Ccb->FileUnwindInfo.LastAccessTime.QuadPart != (ULONGLONG)-1)
7099     {
7100         Ccb->DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = Ccb->FileUnwindInfo.LastAccessTime.QuadPart;
7101     }
7102
7103     if( Ccb->FileUnwindInfo.LastWriteTime.QuadPart != (ULONGLONG)-1)
7104     {
7105         Ccb->DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = Ccb->FileUnwindInfo.LastWriteTime.QuadPart;
7106     }
7107
7108     if( Ccb->FileUnwindInfo.ChangeTime.QuadPart != (ULONGLONG)-1)
7109     {
7110         Ccb->DirectoryCB->ObjectInformation->ChangeTime.QuadPart = Ccb->FileUnwindInfo.ChangeTime.QuadPart;
7111     }
7112
7113     return;
7114 }
7115
7116 BOOLEAN
7117 AFSValidateDirList( IN AFSObjectInfoCB *ObjectInfo)
7118 {
7119
7120     BOOLEAN bIsValid = TRUE;
7121     ULONG ulCount = 0;
7122     AFSDirectoryCB *pCurrentDirEntry = NULL;
7123
7124     pCurrentDirEntry = ObjectInfo->Specific.Directory.DirectoryNodeListHead;
7125
7126     while( pCurrentDirEntry != NULL)
7127     {
7128
7129         if( !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_FAKE))
7130         {
7131             ulCount++;
7132         }
7133
7134         pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
7135     }
7136
7137     if( ulCount != ObjectInfo->Specific.Directory.DirectoryNodeCount)
7138     {
7139
7140         AFSPrint("AFSValidateDirList Count off Calc: %d Stored: %d\n",
7141                   ulCount,
7142                   ObjectInfo->Specific.Directory.DirectoryNodeCount);
7143
7144         ObjectInfo->Specific.Directory.DirectoryNodeCount = ulCount;
7145
7146         bIsValid = FALSE;
7147     }
7148
7149     return bIsValid;
7150 }
7151
7152 PFILE_OBJECT
7153 AFSReferenceCacheFileObject()
7154 {
7155
7156     AFSDeviceExt       *pRdrDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
7157     FILE_OBJECT        *pCacheFileObject = NULL;
7158
7159     AFSAcquireShared( &pRdrDevExt->Specific.RDR.CacheFileLock,
7160                       TRUE);
7161
7162     pCacheFileObject = pRdrDevExt->Specific.RDR.CacheFileObject;
7163
7164     if( pCacheFileObject != NULL)
7165     {
7166         ObReferenceObject( pCacheFileObject);
7167     }
7168
7169     AFSReleaseResource( &pRdrDevExt->Specific.RDR.CacheFileLock);
7170
7171     return pCacheFileObject;
7172 }
7173
7174 void
7175 AFSReleaseCacheFileObject( IN PFILE_OBJECT CacheFileObject)
7176 {
7177
7178     ASSERT( CacheFileObject != NULL);
7179
7180     ObDereferenceObject( CacheFileObject);
7181
7182     return;
7183 }
7184
7185 NTSTATUS
7186 AFSInitializeLibrary( IN AFSLibraryInitCB *LibraryInit)
7187 {
7188
7189     NTSTATUS ntStatus = STATUS_SUCCESS;
7190     AFSDeviceExt *pControlDevExt = NULL;
7191     ULONG ulTimeIncrement = 0;
7192
7193     __Enter
7194     {
7195
7196         AFSControlDeviceObject = LibraryInit->AFSControlDeviceObject;
7197
7198         AFSRDRDeviceObject = LibraryInit->AFSRDRDeviceObject;
7199
7200         AFSServerName = LibraryInit->AFSServerName;
7201
7202         AFSDebugFlags = LibraryInit->AFSDebugFlags;
7203
7204         //
7205         // Callbacks in the framework
7206         //
7207
7208         AFSProcessRequest = LibraryInit->AFSProcessRequest;
7209
7210         AFSDbgLogMsg = LibraryInit->AFSDbgLogMsg;
7211
7212         AFSAddConnectionEx = LibraryInit->AFSAddConnectionEx;
7213
7214         AFSExAllocatePoolWithTag = LibraryInit->AFSExAllocatePoolWithTag;
7215
7216         AFSExFreePool = LibraryInit->AFSExFreePool;
7217
7218         AFSDumpTraceFilesFnc = LibraryInit->AFSDumpTraceFiles;
7219
7220         AFSRetrieveAuthGroupFnc = LibraryInit->AFSRetrieveAuthGroup;
7221
7222         AFSLibCacheManagerCallbacks = LibraryInit->AFSCacheManagerCallbacks;
7223
7224         if( LibraryInit->AFSCacheBaseAddress != NULL)
7225         {
7226
7227             SetFlag( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE);
7228
7229             AFSLibCacheBaseAddress = LibraryInit->AFSCacheBaseAddress;
7230
7231             AFSLibCacheLength = LibraryInit->AFSCacheLength;
7232         }
7233
7234         //
7235         // Initialize some flush parameters
7236         //
7237
7238         pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
7239
7240         ulTimeIncrement = KeQueryTimeIncrement();
7241
7242         pControlDevExt->Specific.Control.ObjectLifeTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)AFS_OBJECT_LIFETIME / (ULONGLONG)ulTimeIncrement);
7243         pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart = AFS_ONE_SECOND;
7244         pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart *= AFS_SERVER_PURGE_DELAY;
7245         pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart /= ulTimeIncrement;
7246         pControlDevExt->Specific.Control.FcbFlushTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)(AFS_ONE_SECOND * AFS_SERVER_FLUSH_DELAY) / (ULONGLONG)ulTimeIncrement);
7247         pControlDevExt->Specific.Control.ExtentRequestTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)AFS_EXTENT_REQUEST_TIME/(ULONGLONG)ulTimeIncrement);
7248
7249         //
7250         // Initialize the global root entry
7251         //
7252
7253         ntStatus = AFSInitVolume( NULL,
7254                                   &LibraryInit->GlobalRootFid,
7255                                   &AFSGlobalRoot);
7256
7257         if( !NT_SUCCESS( ntStatus))
7258         {
7259
7260             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
7261                           AFS_TRACE_LEVEL_ERROR,
7262                           "AFSInitializeLibrary AFSInitVolume failure %08lX\n",
7263                           ntStatus);
7264
7265             try_return( ntStatus);
7266         }
7267
7268         ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
7269                                    AFSGlobalRoot);
7270
7271         if( !NT_SUCCESS( ntStatus))
7272         {
7273
7274             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
7275                           AFS_TRACE_LEVEL_ERROR,
7276                           "AFSInitializeLibrary AFSInitRootFcb failure %08lX\n",
7277                           ntStatus);
7278
7279             AFSReleaseResource( AFSGlobalRoot->VolumeLock);
7280
7281             try_return( ntStatus);
7282         }
7283
7284         //
7285         // Update the node type code to AFS_ROOT_ALL
7286         //
7287
7288         AFSGlobalRoot->ObjectInformation.Fcb->Header.NodeTypeCode = AFS_ROOT_ALL;
7289
7290         SetFlag( AFSGlobalRoot->Flags, AFS_VOLUME_ACTIVE_GLOBAL_ROOT);
7291
7292         //
7293         // Drop the locks acquired above
7294         //
7295
7296         AFSInitVolumeWorker( AFSGlobalRoot);
7297
7298         AFSReleaseResource( AFSGlobalRoot->VolumeLock);
7299
7300         AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Fcb->Header.Resource);
7301
7302 try_exit:
7303
7304         NOTHING;
7305     }
7306
7307     return ntStatus;
7308 }
7309
7310 NTSTATUS
7311 AFSCloseLibrary()
7312 {
7313
7314     NTSTATUS ntStatus = STATUS_SUCCESS;
7315     AFSDirectoryCB *pDirNode = NULL, *pLastDirNode = NULL;
7316
7317     __Enter
7318     {
7319
7320         if( AFSGlobalDotDirEntry != NULL)
7321         {
7322
7323             AFSDeleteObjectInfo( AFSGlobalDotDirEntry->ObjectInformation);
7324
7325             ExDeleteResourceLite( &AFSGlobalDotDirEntry->NonPaged->Lock);
7326
7327             ExFreePool( AFSGlobalDotDirEntry->NonPaged);
7328
7329             ExFreePool( AFSGlobalDotDirEntry);
7330
7331             AFSGlobalDotDirEntry = NULL;
7332         }
7333
7334         if( AFSGlobalDotDotDirEntry != NULL)
7335         {
7336
7337             AFSDeleteObjectInfo( AFSGlobalDotDotDirEntry->ObjectInformation);
7338
7339             ExDeleteResourceLite( &AFSGlobalDotDotDirEntry->NonPaged->Lock);
7340
7341             ExFreePool( AFSGlobalDotDotDirEntry->NonPaged);
7342
7343             ExFreePool( AFSGlobalDotDotDirEntry);
7344
7345             AFSGlobalDotDotDirEntry = NULL;
7346         }
7347
7348         if( AFSSpecialShareNames != NULL)
7349         {
7350
7351             pDirNode = AFSSpecialShareNames;
7352
7353             while( pDirNode != NULL)
7354             {
7355
7356                 pLastDirNode = (AFSDirectoryCB *)pDirNode->ListEntry.fLink;
7357
7358                 AFSDeleteObjectInfo( pDirNode->ObjectInformation);
7359
7360                 ExDeleteResourceLite( &pDirNode->NonPaged->Lock);
7361
7362                 ExFreePool( pDirNode->NonPaged);
7363
7364                 ExFreePool( pDirNode);
7365
7366                 pDirNode = pLastDirNode;
7367             }
7368
7369             AFSSpecialShareNames = NULL;
7370         }
7371     }
7372
7373     return ntStatus;
7374 }
7375
7376 NTSTATUS
7377 AFSDefaultLogMsg( IN ULONG Subsystem,
7378                   IN ULONG Level,
7379                   IN PCCH Format,
7380                   ...)
7381 {
7382
7383     NTSTATUS ntStatus = STATUS_SUCCESS;
7384     va_list va_args;
7385     char chDebugBuffer[ 256];
7386
7387     __Enter
7388     {
7389
7390         va_start( va_args, Format);
7391
7392         ntStatus = RtlStringCbVPrintfA( chDebugBuffer,
7393                                         256,
7394                                         Format,
7395                                         va_args);
7396
7397         if( NT_SUCCESS( ntStatus))
7398         {
7399             DbgPrint( chDebugBuffer);
7400         }
7401
7402         va_end( va_args);
7403     }
7404
7405     return ntStatus;
7406 }
7407
7408 NTSTATUS
7409 AFSGetObjectStatus( IN AFSGetStatusInfoCB *GetStatusInfo,
7410                     IN ULONG InputBufferLength,
7411                     IN AFSStatusInfoCB *StatusInfo,
7412                     OUT ULONG *ReturnLength)
7413 {
7414
7415     NTSTATUS ntStatus = STATUS_SUCCESS;
7416     AFSFcb   *pFcb = NULL;
7417     AFSVolumeCB *pVolumeCB = NULL;
7418     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
7419     AFSObjectInfoCB *pObjectInfo = NULL;
7420     ULONGLONG   ullIndex = 0;
7421     UNICODE_STRING uniFullPathName, uniRemainingPath, uniComponentName, uniParsedName;
7422     AFSNameArrayHdr *pNameArray = NULL;
7423     AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
7424
7425     __Enter
7426     {
7427
7428         //
7429         // If we are given a FID then look up the entry by that, otherwise
7430         // do it by name
7431         //
7432
7433         if( GetStatusInfo->FileID.Cell != 0 &&
7434             GetStatusInfo->FileID.Volume != 0 &&
7435             GetStatusInfo->FileID.Vnode != 0 &&
7436             GetStatusInfo->FileID.Unique != 0)
7437         {
7438
7439             AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
7440
7441             //
7442             // Locate the volume node
7443             //
7444
7445             ullIndex = AFSCreateHighIndex( &GetStatusInfo->FileID);
7446
7447             ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
7448                                            ullIndex,
7449                                            (AFSBTreeEntry **)&pVolumeCB);
7450
7451             if( pVolumeCB != NULL)
7452             {
7453
7454                 InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
7455
7456                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
7457                               AFS_TRACE_LEVEL_VERBOSE,
7458                               "AFSGetObjectStatus Increment count on volume %08lX Cnt %d\n",
7459                               pVolumeCB,
7460                               pVolumeCB->VolumeReferenceCount);
7461             }
7462
7463             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
7464
7465             if( !NT_SUCCESS( ntStatus) ||
7466                 pVolumeCB == NULL)
7467             {
7468                 try_return( ntStatus = STATUS_INVALID_PARAMETER);
7469             }
7470
7471             if( AFSIsVolumeFID( &GetStatusInfo->FileID))
7472             {
7473
7474                 pObjectInfo = &pVolumeCB->ObjectInformation;
7475
7476                 InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
7477
7478                 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
7479             }
7480             else
7481             {
7482
7483                 AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
7484                                   TRUE);
7485
7486                 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
7487
7488                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
7489                               AFS_TRACE_LEVEL_VERBOSE,
7490                               "AFSGetObjectStatus Decrement count on volume %08lX Cnt %d\n",
7491                               pVolumeCB,
7492                               pVolumeCB->VolumeReferenceCount);
7493
7494                 ullIndex = AFSCreateLowIndex( &GetStatusInfo->FileID);
7495
7496                 ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
7497                                                ullIndex,
7498                                                (AFSBTreeEntry **)&pObjectInfo);
7499
7500                 if( pObjectInfo != NULL)
7501                 {
7502
7503                     //
7504                     // Reference the node so it won't be torn down
7505                     //
7506
7507                     InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
7508
7509                     AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
7510                                   AFS_TRACE_LEVEL_VERBOSE,
7511                                   "AFSGetObjectStatus Increment count on object %08lX Cnt %d\n",
7512                                   pObjectInfo,
7513                                   pObjectInfo->ObjectReferenceCount);
7514                 }
7515
7516                 AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
7517
7518                 if( !NT_SUCCESS( ntStatus) ||
7519                     pObjectInfo == NULL)
7520                 {
7521                     try_return( ntStatus = STATUS_INVALID_PARAMETER);
7522                 }
7523             }
7524         }
7525         else
7526         {
7527
7528             if( GetStatusInfo->FileNameLength == 0 ||
7529                 InputBufferLength < (ULONG)(FIELD_OFFSET( AFSGetStatusInfoCB, FileName) + GetStatusInfo->FileNameLength))
7530             {
7531                 try_return( ntStatus = STATUS_INVALID_PARAMETER);
7532             }
7533
7534             uniFullPathName.Length = GetStatusInfo->FileNameLength;
7535             uniFullPathName.MaximumLength = uniFullPathName.Length;
7536
7537             uniFullPathName.Buffer = (WCHAR *)GetStatusInfo->FileName;
7538
7539             //
7540             // This name should begin with the \afs server so parse it off and check it
7541             //
7542
7543             FsRtlDissectName( uniFullPathName,
7544                               &uniComponentName,
7545                               &uniRemainingPath);
7546
7547             if( RtlCompareUnicodeString( &uniComponentName,
7548                                          &AFSServerName,
7549                                          TRUE) != 0)
7550             {
7551                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7552                               AFS_TRACE_LEVEL_ERROR,
7553                               "AFSGetObjectStatus Name %wZ contains invalid server name\n",
7554                               &uniFullPathName);
7555
7556                 try_return( ntStatus = STATUS_OBJECT_PATH_INVALID);
7557             }
7558
7559             uniFullPathName = uniRemainingPath;
7560
7561             uniParsedName = uniFullPathName;
7562
7563             //
7564             // Our name array
7565             //
7566
7567             pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
7568                                            0);
7569
7570             if( pNameArray == NULL)
7571             {
7572                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
7573             }
7574
7575             pVolumeCB = AFSGlobalRoot;
7576
7577             AFSAcquireShared( pVolumeCB->VolumeLock,
7578                               TRUE);
7579
7580             pParentDirEntry = AFSGlobalRoot->DirectoryCB;
7581
7582             //
7583             // Increment the ref count on the volume and dir entry for correct processing below
7584             //
7585
7586             InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
7587
7588             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
7589                           AFS_TRACE_LEVEL_VERBOSE,
7590                           "AFSGetObjectStatus Increment count on volume %08lX Cnt %d\n",
7591                           pVolumeCB,
7592                           pVolumeCB->VolumeReferenceCount);
7593
7594             InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
7595
7596             AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
7597                           AFS_TRACE_LEVEL_VERBOSE,
7598                           "AFSGetObjectStatus Increment count on %wZ DE %p Ccb %p Cnt %d\n",
7599                           &pParentDirEntry->NameInformation.FileName,
7600                           pParentDirEntry,
7601                           NULL,
7602                           pParentDirEntry->OpenReferenceCount);
7603
7604             ntStatus = AFSLocateNameEntry( NULL,
7605                                            NULL,
7606                                            &uniFullPathName,
7607                                            &uniParsedName,
7608                                            pNameArray,
7609                                            AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL |
7610                                                         AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL,
7611                                            &pVolumeCB,
7612                                            &pParentDirEntry,
7613                                            &pDirectoryEntry,
7614                                            NULL);
7615
7616             if( !NT_SUCCESS( ntStatus))
7617             {
7618
7619                 //
7620                 // The volume lock was released on failure above
7621                 // Except for STATUS_OBJECT_NAME_NOT_FOUND
7622                 //
7623
7624                 if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
7625                 {
7626
7627                     if( pVolumeCB != NULL)
7628                     {
7629
7630                         InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
7631
7632                         AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
7633                                       AFS_TRACE_LEVEL_VERBOSE,
7634                                       "AFSGetObjectStatus Decrement count on volume %08lX Cnt %d\n",
7635                                       pVolumeCB,
7636                                       pVolumeCB->VolumeReferenceCount);
7637
7638                         AFSReleaseResource( pVolumeCB->VolumeLock);
7639                     }
7640
7641                     if( pDirectoryEntry != NULL)
7642                     {
7643
7644                         InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
7645
7646                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
7647                                       AFS_TRACE_LEVEL_VERBOSE,
7648                                       "AFSGetObjectStatus Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
7649                                       &pDirectoryEntry->NameInformation.FileName,
7650                                       pDirectoryEntry,
7651                                       NULL,
7652                                       pDirectoryEntry->OpenReferenceCount);
7653                     }
7654                     else
7655                     {
7656
7657                         InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
7658
7659                         AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
7660                                       AFS_TRACE_LEVEL_VERBOSE,
7661                                       "AFSGetObjectStatus Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
7662                                       &pParentDirEntry->NameInformation.FileName,
7663                                       pParentDirEntry,
7664                                       NULL,
7665                                       pParentDirEntry->OpenReferenceCount);
7666                     }
7667                 }
7668
7669                 pVolumeCB = NULL;
7670
7671                 try_return( ntStatus);
7672             }
7673
7674             //
7675             // Remove the reference made above
7676             //
7677
7678             InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
7679
7680             pObjectInfo = pDirectoryEntry->ObjectInformation;
7681
7682             InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
7683
7684             if( pVolumeCB != NULL)
7685             {
7686
7687                 InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
7688
7689                 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
7690                               AFS_TRACE_LEVEL_VERBOSE,
7691                               "AFSRetrieveFileAttributes Decrement2 count on volume %08lX Cnt %d\n",
7692                               pVolumeCB,
7693                               pVolumeCB->VolumeReferenceCount);
7694
7695                 AFSReleaseResource( pVolumeCB->VolumeLock);
7696             }
7697         }
7698
7699         //
7700         // At this point we have an object info block, return the information
7701         //
7702
7703         StatusInfo->FileId = pObjectInfo->FileId;
7704
7705         StatusInfo->TargetFileId = pObjectInfo->TargetFileId;
7706
7707         StatusInfo->Expiration = pObjectInfo->Expiration;
7708
7709         StatusInfo->DataVersion = pObjectInfo->DataVersion;
7710
7711         StatusInfo->FileType = pObjectInfo->FileType;
7712
7713         StatusInfo->ObjectFlags = pObjectInfo->Flags;
7714
7715         StatusInfo->CreationTime = pObjectInfo->CreationTime;
7716
7717         StatusInfo->LastAccessTime = pObjectInfo->LastAccessTime;
7718
7719         StatusInfo->LastWriteTime = pObjectInfo->LastWriteTime;
7720
7721         StatusInfo->ChangeTime = pObjectInfo->ChangeTime;
7722
7723         StatusInfo->FileAttributes = pObjectInfo->FileAttributes;
7724
7725         StatusInfo->EndOfFile = pObjectInfo->EndOfFile;
7726
7727         StatusInfo->AllocationSize = pObjectInfo->AllocationSize;
7728
7729         StatusInfo->EaSize = pObjectInfo->EaSize;
7730
7731         StatusInfo->Links = pObjectInfo->Links;
7732
7733         //
7734         // Return the information length
7735         //
7736
7737         *ReturnLength = sizeof( AFSStatusInfoCB);
7738
7739 try_exit:
7740
7741         if( pObjectInfo != NULL)
7742         {
7743
7744             InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
7745         }
7746
7747         if( pNameArray != NULL)
7748         {
7749
7750             AFSFreeNameArray( pNameArray);
7751         }
7752     }
7753
7754     return ntStatus;
7755 }
7756
7757 NTSTATUS
7758 AFSCheckSymlinkAccess( IN AFSDirectoryCB *ParentDirectoryCB,
7759                        IN UNICODE_STRING *ComponentName)
7760 {
7761
7762     NTSTATUS ntStatus = STATUS_SUCCESS;
7763     AFSDirectoryCB *pDirEntry = NULL;
7764     ULONG ulCRC = 0;
7765
7766     __Enter
7767     {
7768
7769         //
7770         // Search for the entry in the parent
7771         //
7772
7773         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7774                       AFS_TRACE_LEVEL_VERBOSE_2,
7775                       "AFSCheckSymlinkAccess Searching for entry %wZ case sensitive\n",
7776                       ComponentName);
7777
7778         ulCRC = AFSGenerateCRC( ComponentName,
7779                                 FALSE);
7780
7781         AFSAcquireShared( ParentDirectoryCB->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
7782                           TRUE);
7783
7784         AFSLocateCaseSensitiveDirEntry( ParentDirectoryCB->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
7785                                         ulCRC,
7786                                         &pDirEntry);
7787
7788         if( pDirEntry == NULL)
7789         {
7790
7791             //
7792             // Missed so perform a case insensitive lookup
7793             //
7794
7795             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7796                           AFS_TRACE_LEVEL_VERBOSE_2,
7797                           "AFSCheckSymlinkAccess Searching for entry %wZ case insensitive\n",
7798                           ComponentName);
7799
7800             ulCRC = AFSGenerateCRC( ComponentName,
7801                                     TRUE);
7802
7803             AFSLocateCaseInsensitiveDirEntry( ParentDirectoryCB->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
7804                                               ulCRC,
7805                                               &pDirEntry);
7806
7807             if( pDirEntry == NULL)
7808             {
7809
7810                 //
7811                 // OK, if this component is a valid short name then try
7812                 // a lookup in the short name tree
7813                 //
7814
7815                 if( RtlIsNameLegalDOS8Dot3( ComponentName,
7816                                             NULL,
7817                                             NULL))
7818                 {
7819
7820                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7821                                   AFS_TRACE_LEVEL_VERBOSE_2,
7822                                   "AFSCheckSymlinkAccess Searching for entry %wZ short name\n",
7823                                   ComponentName);
7824
7825                     AFSLocateShortNameDirEntry( ParentDirectoryCB->ObjectInformation->Specific.Directory.ShortNameTree,
7826                                                 ulCRC,
7827                                                 &pDirEntry);
7828                 }
7829             }
7830         }
7831
7832         if( pDirEntry != NULL)
7833         {
7834             InterlockedIncrement( &pDirEntry->OpenReferenceCount);
7835         }
7836
7837         AFSReleaseResource( ParentDirectoryCB->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
7838
7839         if( pDirEntry == NULL)
7840         {
7841
7842             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7843                           AFS_TRACE_LEVEL_VERBOSE_2,
7844                           "AFSCheckSymlinkAccess Failed to locate entry %wZ\n",
7845                           ComponentName);
7846
7847             try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
7848         }
7849
7850         //
7851         // We have the symlink object but previously failed to process it so return access
7852         // denied.
7853         //
7854
7855         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
7856                       AFS_TRACE_LEVEL_VERBOSE_2,
7857                       "AFSCheckSymlinkAccess Failing symlink access to entry %wZ ACCESS_DENIED\n",
7858                       ComponentName);
7859
7860         ntStatus = STATUS_ACCESS_DENIED;
7861
7862         InterlockedDecrement( &pDirEntry->OpenReferenceCount);
7863
7864 try_exit:
7865
7866         NOTHING;
7867     }
7868
7869     return ntStatus;
7870 }
7871
7872 NTSTATUS
7873 AFSRetrieveFinalComponent( IN UNICODE_STRING *FullPathName,
7874                            OUT UNICODE_STRING *ComponentName)
7875 {
7876
7877     NTSTATUS ntStatus = STATUS_SUCCESS;
7878     UNICODE_STRING uniFullPathName, uniRemainingPath, uniComponentName;
7879
7880     uniFullPathName = *FullPathName;
7881
7882     while( TRUE)
7883     {
7884
7885         FsRtlDissectName( uniFullPathName,
7886                           &uniComponentName,
7887                           &uniRemainingPath);
7888
7889         if( uniRemainingPath.Length == 0)
7890         {
7891             break;
7892         }
7893
7894         uniFullPathName = uniRemainingPath;
7895     }
7896
7897     if( uniComponentName.Length > 0)
7898     {
7899         *ComponentName = uniComponentName;
7900     }
7901
7902     return ntStatus;
7903 }
7904
7905 void
7906 AFSDumpTraceFiles_Default()
7907 {
7908     return;
7909 }
7910
7911 BOOLEAN
7912 AFSValidNameFormat( IN UNICODE_STRING *FileName)
7913 {
7914
7915     BOOLEAN bIsValidName = TRUE;
7916     USHORT usIndex = 0;
7917
7918     __Enter
7919     {
7920
7921         while( usIndex < FileName->Length/sizeof( WCHAR))
7922         {
7923
7924             if( FileName->Buffer[ usIndex] == L':' ||
7925                 FileName->Buffer[ usIndex] == L'*' ||
7926                 FileName->Buffer[ usIndex] == L'?' ||
7927                 FileName->Buffer[ usIndex] == L'"' ||
7928                 FileName->Buffer[ usIndex] == L'<' ||
7929                 FileName->Buffer[ usIndex] == L'>')
7930             {
7931                 bIsValidName = FALSE;
7932                 break;
7933             }
7934
7935             usIndex++;
7936         }
7937     }
7938
7939     return bIsValidName;
7940 }
7941
7942 NTSTATUS
7943 AFSCreateDefaultSecurityDescriptor()
7944 {
7945
7946     NTSTATUS ntStatus = STATUS_SUCCESS;
7947     PACL pSACL = NULL;
7948     ULONG ulSACLSize = 0;
7949     SYSTEM_MANDATORY_LABEL_ACE* pACE = NULL;
7950     ULONG ulACESize = 0;
7951     SECURITY_DESCRIPTOR *pSecurityDescr = NULL;
7952     ULONG ulSDLength = 0;
7953     SECURITY_DESCRIPTOR *pRelativeSecurityDescr = NULL;
7954
7955     __Enter
7956     {
7957
7958         if( AFSRtlSetSaclSecurityDescriptor == NULL)
7959         {
7960
7961             AFSPrint( "AFSCreateDefaultSecurityDescriptor AFSRtlSetSaclSecurityDescriptor == NULL\n");
7962         }
7963         else
7964         {
7965
7966             ulACESize = sizeof( SYSTEM_MANDATORY_LABEL_ACE) + 128;
7967
7968             pACE = (SYSTEM_MANDATORY_LABEL_ACE *)ExAllocatePoolWithTag( PagedPool,
7969                                                                         ulACESize,
7970                                                                         AFS_GENERIC_MEMORY_29_TAG);
7971
7972             if( pACE == NULL)
7973             {
7974
7975                 AFSPrint( "AFSCreateDefaultSecurityDescriptor unable to allocate AFS_GENERIC_MEMORY_29_TAG\n");
7976
7977                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
7978             }
7979
7980             RtlZeroMemory( pACE,
7981                            ulACESize);
7982
7983             pACE->Header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE;
7984             pACE->Header.AceType = SYSTEM_MANDATORY_LABEL_ACE_TYPE;
7985             pACE->Header.AceSize = FIELD_OFFSET( SYSTEM_MANDATORY_LABEL_ACE, SidStart) + (USHORT)RtlLengthSid( SeExports->SeLowMandatorySid);
7986             pACE->Mask = SYSTEM_MANDATORY_LABEL_NO_WRITE_UP;
7987
7988             RtlCopySid( RtlLengthSid( SeExports->SeLowMandatorySid),
7989                         &pACE->SidStart,
7990                         SeExports->SeLowMandatorySid);
7991
7992             ulSACLSize = sizeof(ACL) + RtlLengthSid( SeExports->SeLowMandatorySid) +
7993                 FIELD_OFFSET( SYSTEM_MANDATORY_LABEL_ACE, SidStart) + ulACESize;
7994
7995             pSACL = (PACL)ExAllocatePoolWithTag( PagedPool,
7996                                                  ulSACLSize,
7997                                                  AFS_GENERIC_MEMORY_29_TAG);
7998
7999             if( pSACL == NULL)
8000             {
8001
8002                 AFSPrint( "AFSCreateDefaultSecurityDescriptor unable to allocate AFS_GENERIC_MEMORY_29_TAG\n");
8003
8004                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
8005             }
8006
8007             ntStatus = RtlCreateAcl( pSACL,
8008                                      ulSACLSize,
8009                                      ACL_REVISION);
8010
8011             if( !NT_SUCCESS( ntStatus))
8012             {
8013
8014                 AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlCreateAcl ntStatus %08lX\n",
8015                           ntStatus);
8016
8017                 try_return( ntStatus);
8018             }
8019
8020             ntStatus = RtlAddAce( pSACL,
8021                                   ACL_REVISION,
8022                                   0,
8023                                   pACE,
8024                                   pACE->Header.AceSize);
8025
8026             if( !NT_SUCCESS( ntStatus))
8027             {
8028
8029                 AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlAddAce ntStatus %08lX\n",
8030                           ntStatus);
8031
8032                 try_return( ntStatus);
8033             }
8034         }
8035
8036         pSecurityDescr = (SECURITY_DESCRIPTOR *)ExAllocatePoolWithTag( NonPagedPool,
8037                                                                        sizeof( SECURITY_DESCRIPTOR),
8038                                                                        AFS_GENERIC_MEMORY_27_TAG);
8039
8040         if( pSecurityDescr == NULL)
8041         {
8042
8043             AFSPrint( "AFSCreateDefaultSecurityDescriptor unable to allocate AFS_GENERIC_MEMORY_27_TAG\n");
8044
8045             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
8046         }
8047
8048         ntStatus = RtlCreateSecurityDescriptor( pSecurityDescr,
8049                                                 SECURITY_DESCRIPTOR_REVISION);
8050
8051         if( !NT_SUCCESS( ntStatus))
8052         {
8053
8054             AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlCreateSecurityDescriptor ntStatus %08lX\n",
8055                       ntStatus);
8056
8057             try_return( ntStatus);
8058         }
8059
8060         if( AFSRtlSetSaclSecurityDescriptor != NULL)
8061         {
8062             ntStatus = AFSRtlSetSaclSecurityDescriptor( pSecurityDescr,
8063                                                         TRUE,
8064                                                         pSACL,
8065                                                         FALSE);
8066
8067             if( !NT_SUCCESS( ntStatus))
8068             {
8069
8070                 AFSPrint( "AFSCreateDefaultSecurityDescriptor AFSRtlSetSaclSecurityDescriptor ntStatus %08lX\n",
8071                           ntStatus);
8072
8073                 try_return( ntStatus);
8074             }
8075         }
8076
8077         if( !RtlValidSecurityDescriptor( pSecurityDescr))
8078         {
8079
8080             AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlValidSecurityDescriptor NOT\n");
8081
8082             try_return( ntStatus = STATUS_INVALID_PARAMETER);
8083         }
8084
8085         pRelativeSecurityDescr = (SECURITY_DESCRIPTOR *)ExAllocatePoolWithTag( NonPagedPool,
8086                                                                                PAGE_SIZE,
8087                                                                                AFS_GENERIC_MEMORY_27_TAG);
8088
8089         if( pRelativeSecurityDescr == NULL)
8090         {
8091
8092             AFSPrint( "AFSCreateDefaultSecurityDescriptor unable to allocate AFS_GENERIC_MEMORY_27_TAG\n");
8093
8094             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
8095         }
8096
8097         ulSDLength = PAGE_SIZE;
8098
8099         ntStatus = RtlAbsoluteToSelfRelativeSD( pSecurityDescr,
8100                                                 pRelativeSecurityDescr,
8101                                                 &ulSDLength);
8102
8103         if( !NT_SUCCESS( ntStatus))
8104         {
8105
8106             AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlAbsoluteToSelfRelativeSD ntStatus %08lX\n",
8107                       ntStatus);
8108
8109             try_return( ntStatus);
8110         }
8111
8112         AFSDefaultSD = pRelativeSecurityDescr;
8113
8114 try_exit:
8115
8116         if( !NT_SUCCESS( ntStatus))
8117         {
8118
8119             if( pRelativeSecurityDescr != NULL)
8120             {
8121                 ExFreePool( pRelativeSecurityDescr);
8122             }
8123         }
8124
8125         if( pSecurityDescr != NULL)
8126         {
8127             ExFreePool( pSecurityDescr);
8128         }
8129
8130         if( pSACL != NULL)
8131         {
8132             ExFreePool( pSACL);
8133         }
8134
8135         if( pACE != NULL)
8136         {
8137             ExFreePool( pACE);
8138         }
8139     }
8140
8141     return ntStatus;
8142 }