2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
14 * this list of conditions and the following disclaimer in the
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.
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.
36 // File: AFSNameSupport.cpp
39 #include "AFSCommon.h"
44 // On entry, *VolumeCB must have a held ReferenceCount provided by
45 // the caller which will not be released. On successful exit, *OutVolumeCB
46 // will be assigned the new current volume with a held ReferenceCount.
48 // On entry, *ParentDirectoryCB must have a held DirOpenReferenceCount
49 // provided by the caller. This reference will not be released.
50 // On exit, if OutParentDirectoryCB is set, it will have a new reference.
52 // On exit, if OutDirectoryCB is set, it will have a reference.
56 AFSLocateNameEntry( IN GUID *AuthGroup,
57 IN PFILE_OBJECT FileObject,
58 IN OUT UNICODE_STRING *RootPathName,
59 IN UNICODE_STRING *ParsedPathName,
60 IN AFSNameArrayHdr *NameArray,
62 IN AFSVolumeCB *VolumeCB,
63 IN AFSDirectoryCB *ParentDirectoryCB,
64 OUT AFSVolumeCB **OutVolumeCB,
65 OUT LONG *OutVolumeReferenceReason,
66 OUT AFSDirectoryCB **OutParentDirectoryCB,
67 OUT AFSDirectoryCB **OutDirectoryCB,
68 OUT PUNICODE_STRING ComponentName)
71 NTSTATUS ntStatus = STATUS_SUCCESS;
72 UNICODE_STRING uniPathName, uniComponentName, uniRemainingPath, uniSearchName, uniFullPathName;
74 AFSDirectoryCB *pDirEntry = NULL, *pParentDirEntry = NULL;
75 AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
76 UNICODE_STRING uniSysName;
77 ULONG ulSubstituteIndex = 0;
78 BOOLEAN bSubstituteName = FALSE;
79 AFSNameArrayHdr *pNameArray = NameArray;
80 BOOLEAN bAllocatedSymLinkBuffer = FALSE;
81 UNICODE_STRING uniRelativeName, uniNoOpName;
82 AFSObjectInfoCB *pCurrentObject = NULL;
83 AFSObjectInfoCB *pParentObjectInfo = NULL;
84 AFSVolumeCB *pCurrentVolume = NULL;
85 AFSVolumeCB *pTargetVolume = NULL;
86 BOOLEAN bReleaseCurrentVolume = FALSE;
87 LONG VolumeReferenceReason;
88 BOOLEAN bSubstitutedName = FALSE;
94 ASSERT( *OutVolumeCB != VolumeCB);
96 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
97 AFS_TRACE_LEVEL_VERBOSE_2,
98 "AFSLocateNameEntry (FO: %p) Processing full name %wZ\n",
102 RtlInitUnicodeString( &uniSysName,
105 RtlInitUnicodeString( &uniRelativeName,
108 RtlInitUnicodeString( &uniNoOpName,
112 // Cleanup some parameters
115 if( ComponentName != NULL)
118 ComponentName->Length = 0;
119 ComponentName->MaximumLength = 0;
120 ComponentName->Buffer = NULL;
124 // We will parse through the filename, locating the directory nodes until we encounter a cache miss
125 // Starting at the root node
128 pParentDirEntry = NULL;
130 pDirEntry = ParentDirectoryCB;
133 // Increment our reference on this dir entry
136 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
138 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
139 AFS_TRACE_LEVEL_VERBOSE,
140 "AFSLocateNameEntry Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
141 &pDirEntry->NameInformation.FileName,
146 pCurrentVolume = VolumeCB;
148 VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
150 lCount = AFSVolumeIncrement( pCurrentVolume,
151 VolumeReferenceReason);
153 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
154 AFS_TRACE_LEVEL_VERBOSE,
155 "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
157 VolumeReferenceReason,
160 bReleaseCurrentVolume = TRUE;
162 uniPathName = *ParsedPathName;
164 uniFullPathName = *RootPathName;
166 uniComponentName.Length = uniComponentName.MaximumLength = 0;
167 uniComponentName.Buffer = NULL;
169 uniRemainingPath.Length = uniRemainingPath.MaximumLength = 0;
170 uniRemainingPath.Buffer = NULL;
172 uniSearchName.Length = uniSearchName.MaximumLength = 0;
173 uniSearchName.Buffer = NULL;
178 ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
180 ASSERT( pDirEntry->DirOpenReferenceCount > 0);
183 // Check our total link count for this name array
186 if( pNameArray->LinkCount >= (LONG)pDevExt->Specific.RDR.MaxLinkCount)
189 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
192 pCurrentObject = pDirEntry->ObjectInformation;
194 KeQueryTickCount( &pCurrentObject->LastAccessCount);
197 // Check that the directory entry is not deleted or pending delete
200 if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED))
203 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
204 AFS_TRACE_LEVEL_ERROR,
205 "AFSLocateNameEntry (FO: %p) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
207 &pDirEntry->NameInformation.FileName,
208 pCurrentObject->FileId.Cell,
209 pCurrentObject->FileId.Volume,
210 pCurrentObject->FileId.Vnode,
211 pCurrentObject->FileId.Unique,
212 STATUS_FILE_DELETED);
214 try_return( ntStatus = STATUS_FILE_DELETED);
217 if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
220 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
221 AFS_TRACE_LEVEL_ERROR,
222 "AFSLocateNameEntry (FO: %p) Delete pending on %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
224 &pDirEntry->NameInformation.FileName,
225 pCurrentObject->FileId.Cell,
226 pCurrentObject->FileId.Volume,
227 pCurrentObject->FileId.Vnode,
228 pCurrentObject->FileId.Unique,
229 STATUS_DELETE_PENDING);
231 try_return( ntStatus = STATUS_DELETE_PENDING);
235 // Check if the directory requires verification
238 if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY) &&
239 ( pCurrentObject->FileType != AFS_FILE_TYPE_DIRECTORY ||
240 !AFSIsEnumerationInProcess( pCurrentObject)))
243 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
244 AFS_TRACE_LEVEL_VERBOSE,
245 "AFSLocateNameEntry (FO: %p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
247 &pDirEntry->NameInformation.FileName,
248 pCurrentObject->FileId.Cell,
249 pCurrentObject->FileId.Volume,
250 pCurrentObject->FileId.Vnode,
251 pCurrentObject->FileId.Unique);
254 // Directory TreeLock should be exclusively held
257 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
260 ntStatus = AFSVerifyEntry( AuthGroup,
263 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
265 if( !NT_SUCCESS( ntStatus))
268 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
269 AFS_TRACE_LEVEL_ERROR,
270 "AFSLocateNameEntry (FO: %p) Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
272 &pDirEntry->NameInformation.FileName,
273 pCurrentObject->FileId.Cell,
274 pCurrentObject->FileId.Volume,
275 pCurrentObject->FileId.Vnode,
276 pCurrentObject->FileId.Unique,
279 try_return( ntStatus);
284 // Ensure the parent node has been evaluated, if not then go do it now
287 if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) ||
288 pCurrentObject->FileType == AFS_FILE_TYPE_UNKNOWN)
291 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
292 AFS_TRACE_LEVEL_VERBOSE,
293 "AFSLocateNameEntry (FO: %p) Evaluating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
295 &pDirEntry->NameInformation.FileName,
296 pCurrentObject->FileId.Cell,
297 pCurrentObject->FileId.Volume,
298 pCurrentObject->FileId.Vnode,
299 pCurrentObject->FileId.Unique);
301 ntStatus = AFSEvaluateNode( AuthGroup,
304 if( !NT_SUCCESS( ntStatus))
307 if ( ntStatus == STATUS_NOT_A_DIRECTORY)
310 if ( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
313 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
314 AFS_TRACE_LEVEL_ERROR,
315 "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT NULL Status %08lX\n",
317 &pDirEntry->NameInformation.FileName,
318 pCurrentObject->FileId.Cell,
319 pCurrentObject->FileId.Volume,
320 pCurrentObject->FileId.Vnode,
321 pCurrentObject->FileId.Unique,
327 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
328 AFS_TRACE_LEVEL_ERROR,
329 "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX Status %08lX\n",
331 &pDirEntry->NameInformation.FileName,
332 pCurrentObject->FileId.Cell,
333 pCurrentObject->FileId.Volume,
334 pCurrentObject->FileId.Vnode,
335 pCurrentObject->FileId.Unique,
336 pCurrentObject->ParentFileId.Cell,
337 pCurrentObject->ParentFileId.Volume,
338 pCurrentObject->ParentFileId.Vnode,
339 pCurrentObject->ParentFileId.Unique,
345 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
346 AFS_TRACE_LEVEL_ERROR,
347 "AFSLocateNameEntry (FO: %p) Failed to evaluate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
349 &pDirEntry->NameInformation.FileName,
350 pCurrentObject->FileId.Cell,
351 pCurrentObject->FileId.Volume,
352 pCurrentObject->FileId.Vnode,
353 pCurrentObject->FileId.Unique,
357 try_return( ntStatus);
360 ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
364 // If this is a mount point or symlink then go get the real directory node
367 switch( pCurrentObject->FileType)
370 case AFS_FILE_TYPE_SYMLINK:
373 UNICODE_STRING uniTempName;
374 WCHAR *pTmpBuffer = NULL;
378 // Check if the flag is set to NOT evaluate a symlink
379 // and we are done with the parsing
382 if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL) &&
383 uniRemainingPath.Length == 0)
387 // Pass back the directory entries
390 *OutParentDirectoryCB = pParentDirEntry;
392 pParentDirEntry = NULL;
394 *OutDirectoryCB = pDirEntry;
398 *OutVolumeCB = pCurrentVolume;
400 *OutVolumeReferenceReason = VolumeReferenceReason;
402 bReleaseCurrentVolume = FALSE;
404 *RootPathName = uniFullPathName;
406 try_return( ntStatus);
409 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
412 AFSAcquireExcl( &pDirEntry->NonPaged->Lock,
415 if( pDirEntry->NameInformation.TargetName.Length == 0)
419 // We'll reset the DV to ensure we validate the metadata content
422 pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
424 SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
426 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
427 AFS_TRACE_LEVEL_VERBOSE,
428 "AFSLocateNameEntry (FO: %p) Verifying symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
430 &pDirEntry->NameInformation.FileName,
431 pCurrentObject->FileId.Cell,
432 pCurrentObject->FileId.Volume,
433 pCurrentObject->FileId.Vnode,
434 pCurrentObject->FileId.Unique);
437 // Directory TreeLock should be exclusively held
440 ntStatus = AFSVerifyEntry( AuthGroup,
443 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
445 if( !NT_SUCCESS( ntStatus))
448 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
449 AFS_TRACE_LEVEL_ERROR,
450 "AFSLocateNameEntry (FO: %p) Failed to verify symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
452 &pDirEntry->NameInformation.FileName,
453 pCurrentObject->FileId.Cell,
454 pCurrentObject->FileId.Volume,
455 pCurrentObject->FileId.Vnode,
456 pCurrentObject->FileId.Unique,
459 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
461 try_return( ntStatus);
465 // If the type changed then reprocess this entry
468 if( pCurrentObject->FileType != AFS_FILE_TYPE_SYMLINK)
471 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
479 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
483 // If we were given a zero length target name then deny access to the entry
486 if( pDirEntry->NameInformation.TargetName.Length == 0)
489 ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
491 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
492 AFS_TRACE_LEVEL_ERROR,
493 "AFSLocateNameEntry (FO: %p) Failed to retrieve target name for symlink %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
495 &pDirEntry->NameInformation.FileName,
496 pCurrentObject->FileId.Cell,
497 pCurrentObject->FileId.Volume,
498 pCurrentObject->FileId.Vnode,
499 pCurrentObject->FileId.Unique,
502 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
504 try_return( ntStatus);
507 if( AFSIsRelativeName( &pDirEntry->NameInformation.TargetName))
510 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
511 AFS_TRACE_LEVEL_VERBOSE,
512 "AFSLocateNameEntry (FO: %p) Processing relative symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
514 &pDirEntry->NameInformation.TargetName,
515 &pDirEntry->NameInformation.FileName,
516 pCurrentObject->FileId.Cell,
517 pCurrentObject->FileId.Volume,
518 pCurrentObject->FileId.Vnode,
519 pCurrentObject->FileId.Unique);
522 // We'll substitute this name into the current process name
523 // starting at where we sit in the path
526 uniTempName.Length = 0;
527 uniTempName.MaximumLength = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer) +
528 pDirEntry->NameInformation.TargetName.Length +
530 uniRemainingPath.Length;
532 uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
533 uniTempName.MaximumLength,
534 AFS_NAME_BUFFER_ONE_TAG);
536 if( uniTempName.Buffer == NULL)
539 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
541 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
545 // We have so first copy in the portion up to the component
549 RtlCopyMemory( uniTempName.Buffer,
550 uniFullPathName.Buffer,
551 (ULONG)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer));
553 uniTempName.Length = (USHORT)((char *)uniComponentName.Buffer - (char *)uniFullPathName.Buffer);
555 if( bAllocatedSymLinkBuffer ||
559 pTmpBuffer = uniFullPathName.Buffer;
562 bAllocatedSymLinkBuffer = TRUE;
565 // Have we parsed this name yet? Better have at least once ...
568 if( uniComponentName.Length == 0)
574 // Copy in the target name ...
577 RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
578 pDirEntry->NameInformation.TargetName.Buffer,
579 pDirEntry->NameInformation.TargetName.Length);
581 uniPathName.Buffer = &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)];
583 uniPathName.Length += pDirEntry->NameInformation.TargetName.Length;
584 uniPathName.MaximumLength = uniTempName.MaximumLength;
586 uniTempName.Length += pDirEntry->NameInformation.TargetName.Length;
589 // And now any remaining portion of the name
592 if( uniRemainingPath.Length > 0)
595 if( uniRemainingPath.Buffer[ 0] != L'\\')
598 uniRemainingPath.Buffer--;
599 uniRemainingPath.Length += sizeof( WCHAR);
601 uniPathName.Length += sizeof( WCHAR);
604 RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
605 uniRemainingPath.Buffer,
606 uniRemainingPath.Length);
608 uniTempName.Length += uniRemainingPath.Length;
611 uniFullPathName = uniTempName;
613 if( pTmpBuffer != NULL)
616 AFSExFreePoolWithTag( pTmpBuffer, 0);
619 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
622 // Dereference the current entry ..
625 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
627 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
628 AFS_TRACE_LEVEL_VERBOSE,
629 "AFSLocateNameEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
630 &pDirEntry->NameInformation.FileName,
635 ASSERT( lCount >= 0);
638 // OK, need to back up one entry for the correct parent since the current
639 // entry we are on is the symlink itself
642 pDirEntry = AFSBackupEntry( pNameArray);
645 // Increment our reference on this dir entry
648 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
650 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
651 AFS_TRACE_LEVEL_VERBOSE,
652 "AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
653 &pDirEntry->NameInformation.FileName,
658 if ( pParentDirEntry)
661 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
663 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
664 AFS_TRACE_LEVEL_VERBOSE,
665 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
666 &pParentDirEntry->NameInformation.FileName,
671 pParentDirEntry = NULL;
674 if( !BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
677 pParentDirEntry = AFSGetParentEntry( pNameArray);
679 ASSERT( pParentDirEntry != pDirEntry);
681 lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
683 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
684 AFS_TRACE_LEVEL_VERBOSE,
685 "AFSLocateNameEntry Increment count on %wZ DE %p Ccb %p Cnt %d\n",
686 &pParentDirEntry->NameInformation.FileName,
695 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
696 AFS_TRACE_LEVEL_VERBOSE,
697 "AFSLocateNameEntry (FO: %p) Processing absolute symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
699 &pDirEntry->NameInformation.TargetName,
700 &pDirEntry->NameInformation.FileName,
701 pCurrentObject->FileId.Cell,
702 pCurrentObject->FileId.Volume,
703 pCurrentObject->FileId.Vnode,
704 pCurrentObject->FileId.Unique);
706 if ( !AFSIsAbsoluteAFSName( &pDirEntry->NameInformation.TargetName))
709 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
710 AFS_TRACE_LEVEL_ERROR,
711 "AFSLocateNameEntry Name %wZ contains invalid server name\n",
712 &pDirEntry->NameInformation.TargetName);
715 // The correct response would be STATUS_OBJECT_PATH_INVALID
716 // but that prevents cmd.exe from performing a recursive
717 // directory enumeration when opening a directory entry
718 // that represents a symlink to an invalid path is discovered.
721 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
723 try_return( ntStatus = STATUS_OBJECT_PATH_NOT_FOUND);
727 // We'll substitute this name into the current process name
728 // starting at where we sit in the path
731 uniTempName.Length = 0;
732 uniTempName.MaximumLength = pDirEntry->NameInformation.TargetName.Length +
734 uniRemainingPath.Length;
736 uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
737 uniTempName.MaximumLength,
738 AFS_NAME_BUFFER_TWO_TAG);
740 if( uniTempName.Buffer == NULL)
743 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
745 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
748 if( bAllocatedSymLinkBuffer ||
752 pTmpBuffer = uniFullPathName.Buffer;
755 bAllocatedSymLinkBuffer = TRUE;
758 // Have we parsed this name yet? Better have at least once ...
761 if( uniComponentName.Length == 0)
767 // Copy in the target name ...
770 RtlCopyMemory( uniTempName.Buffer,
771 &pDirEntry->NameInformation.TargetName.Buffer[ AFSMountRootName.Length/sizeof( WCHAR)],
772 pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length);
774 uniTempName.Length = pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length;
777 // And now any remaining portion of the name
780 if( uniRemainingPath.Length > 0)
783 if( uniRemainingPath.Buffer[ 0] != L'\\')
786 uniRemainingPath.Buffer--;
787 uniRemainingPath.Length += sizeof( WCHAR);
790 RtlCopyMemory( &uniTempName.Buffer[ uniTempName.Length/sizeof( WCHAR)],
791 uniRemainingPath.Buffer,
792 uniRemainingPath.Length);
794 uniTempName.Length += uniRemainingPath.Length;
797 uniFullPathName = uniTempName;
799 uniPathName = uniTempName;
801 if( pTmpBuffer != NULL)
804 AFSExFreePoolWithTag( pTmpBuffer, 0);
807 AFSReleaseResource( &pDirEntry->NonPaged->Lock);
810 // If our current volume is not the global root then make it so ...
813 if( pCurrentVolume != AFSGlobalRoot)
816 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
817 AFS_TRACE_LEVEL_VERBOSE,
818 "AFSLocateNameEntry (FO: %p) Current volume not global, resetting for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
820 &pDirEntry->NameInformation.FileName,
821 pCurrentObject->FileId.Cell,
822 pCurrentObject->FileId.Volume,
823 pCurrentObject->FileId.Vnode,
824 pCurrentObject->FileId.Unique);
826 lCount = AFSVolumeDecrement( pCurrentVolume,
827 VolumeReferenceReason);
829 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
830 AFS_TRACE_LEVEL_VERBOSE,
831 "AFSLocateNameEntry Decrement count on volume %p Reason %u Cnt %d\n",
833 VolumeReferenceReason,
836 pCurrentVolume = AFSGlobalRoot;
838 VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
840 lCount = AFSVolumeIncrement( pCurrentVolume,
841 VolumeReferenceReason);
843 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
844 AFS_TRACE_LEVEL_VERBOSE,
845 "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
847 VolumeReferenceReason,
852 // Dereference our current dir entry
855 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
857 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
858 AFS_TRACE_LEVEL_VERBOSE,
859 "AFSLocateNameEntry Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
860 &pDirEntry->NameInformation.FileName,
865 ASSERT( lCount >= 0);
867 pDirEntry = pCurrentVolume->DirectoryCB;
870 // Reference the new dir entry
873 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
875 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
876 AFS_TRACE_LEVEL_VERBOSE,
877 "AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
878 &pDirEntry->NameInformation.FileName,
884 // Reset the name array
885 // Persist the link count in the name array
888 lLinkCount = pNameArray->LinkCount;
890 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
891 AFS_TRACE_LEVEL_VERBOSE,
892 "AFSLocateNameEntry (FO: %p) Resetting name array for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
894 &pDirEntry->NameInformation.FileName,
895 pCurrentObject->FileId.Cell,
896 pCurrentObject->FileId.Volume,
897 pCurrentObject->FileId.Vnode,
898 pCurrentObject->FileId.Unique);
900 AFSResetNameArray( pNameArray,
903 pNameArray->LinkCount = lLinkCount;
905 if ( pParentDirEntry)
908 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
910 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
911 AFS_TRACE_LEVEL_VERBOSE,
912 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
913 &pParentDirEntry->NameInformation.FileName,
918 pParentDirEntry = NULL;
923 // Increment our link count
926 lCount = InterlockedIncrement( &pNameArray->LinkCount);
931 case AFS_FILE_TYPE_MOUNTPOINT:
935 // Check if the flag is set to NOT evaluate a mount point
936 // and we are done with the parsing
939 if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL) &&
940 uniRemainingPath.Length == 0)
944 // Pass back the directory entries
947 *OutParentDirectoryCB = pParentDirEntry;
949 pParentDirEntry = NULL;
951 *OutDirectoryCB = pDirEntry;
955 *OutVolumeCB = pCurrentVolume;
957 *OutVolumeReferenceReason = VolumeReferenceReason;
959 bReleaseCurrentVolume = FALSE;
961 *RootPathName = uniFullPathName;
963 try_return( ntStatus);
966 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
967 AFS_TRACE_LEVEL_VERBOSE,
968 "AFSLocateNameEntry (FO: %p) Building MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
970 &pDirEntry->NameInformation.FileName,
971 pCurrentObject->FileId.Cell,
972 pCurrentObject->FileId.Volume,
973 pCurrentObject->FileId.Vnode,
974 pCurrentObject->FileId.Unique);
977 // Go retrieve the target entry for this node
978 // Release the current volume cb entry since we would
979 // have lock inversion in the following call
980 // Also decrement the ref count on the volume
983 ntStatus = AFSBuildMountPointTarget( AuthGroup,
987 if( !NT_SUCCESS( ntStatus))
990 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
991 AFS_TRACE_LEVEL_ERROR,
992 "AFSLocateNameEntry (FO: %p) Failed to build MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
994 &pDirEntry->NameInformation.FileName,
995 pCurrentObject->FileId.Cell,
996 pCurrentObject->FileId.Volume,
997 pCurrentObject->FileId.Vnode,
998 pCurrentObject->FileId.Unique,
1001 try_return( ntStatus);
1004 ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
1006 lCount = AFSVolumeDecrement( pCurrentVolume,
1007 VolumeReferenceReason);
1009 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1010 AFS_TRACE_LEVEL_VERBOSE,
1011 "AFSLocateNameEntry Decrement2 count on volume %p Reason %u Cnt %d\n",
1013 VolumeReferenceReason,
1016 pCurrentVolume = pTargetVolume;
1018 pTargetVolume = NULL;
1020 ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
1022 VolumeReferenceReason = AFS_VOLUME_REFERENCE_MOUNTPT;
1025 // We want to restart processing here on the new parent ...
1026 // Deref and ref count the entries
1029 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1031 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1032 AFS_TRACE_LEVEL_VERBOSE,
1033 "AFSLocateNameEntry Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
1034 &pDirEntry->NameInformation.FileName,
1039 ASSERT( lCount >= 0);
1041 pDirEntry = pCurrentVolume->DirectoryCB;
1043 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1045 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1046 AFS_TRACE_LEVEL_VERBOSE,
1047 "AFSLocateNameEntry Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
1048 &pDirEntry->NameInformation.FileName,
1054 // The name array stores both the mount point and the target.
1055 // Insert the target.
1058 AFSInsertNextElement( pNameArray,
1061 if ( pParentDirEntry)
1064 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
1066 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1067 AFS_TRACE_LEVEL_VERBOSE,
1068 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1069 &pParentDirEntry->NameInformation.FileName,
1074 pParentDirEntry = NULL;
1078 // Increment our link count
1081 lCount = InterlockedIncrement( &pNameArray->LinkCount);
1086 case AFS_FILE_TYPE_DFSLINK:
1089 if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL))
1093 // Pass back the directory entries
1096 *OutParentDirectoryCB = pParentDirEntry;
1098 pParentDirEntry = NULL;
1100 *OutDirectoryCB = pDirEntry;
1104 *OutVolumeCB = pCurrentVolume;
1106 *OutVolumeReferenceReason = VolumeReferenceReason;
1108 bReleaseCurrentVolume = FALSE;
1110 *RootPathName = uniFullPathName;
1112 try_return( ntStatus);
1116 // This is a DFS link so we need to update the file name and return STATUS_REPARSE to the
1117 // system for it to reevaluate it
1120 if( FileObject != NULL)
1123 ntStatus = AFSProcessDFSLink( pDirEntry,
1132 // This is where we have been re-entered from an NP evaluation call via the BuildBranch()
1136 ntStatus = STATUS_INVALID_PARAMETER;
1139 if( ntStatus != STATUS_SUCCESS &&
1140 ntStatus != STATUS_REPARSE)
1143 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1144 AFS_TRACE_LEVEL_ERROR,
1145 "AFSLocateNameEntry (FO: %p) Failed to process DFSLink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1147 &pDirEntry->NameInformation.FileName,
1148 pCurrentObject->FileId.Cell,
1149 pCurrentObject->FileId.Volume,
1150 pCurrentObject->FileId.Vnode,
1151 pCurrentObject->FileId.Unique,
1155 try_return( ntStatus);
1158 case AFS_FILE_TYPE_UNKNOWN:
1159 case AFS_FILE_TYPE_INVALID:
1163 // Something was not processed ...
1166 try_return( ntStatus = STATUS_ACCESS_DENIED);
1169 } /* end of switch */
1172 // If the parent is not initialized then do it now
1175 if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
1176 !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1179 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1180 AFS_TRACE_LEVEL_VERBOSE,
1181 "AFSLocateNameEntry (FO: %p) Enumerating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1183 &pDirEntry->NameInformation.FileName,
1184 pCurrentObject->FileId.Cell,
1185 pCurrentObject->FileId.Volume,
1186 pCurrentObject->FileId.Vnode,
1187 pCurrentObject->FileId.Unique);
1189 AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
1192 if( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1195 ntStatus = AFSEnumerateDirectory( AuthGroup,
1199 if( !NT_SUCCESS( ntStatus))
1202 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1204 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1205 AFS_TRACE_LEVEL_ERROR,
1206 "AFSLocateNameEntry (FO: %p) Failed to enumerate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1208 &pDirEntry->NameInformation.FileName,
1209 pCurrentObject->FileId.Cell,
1210 pCurrentObject->FileId.Volume,
1211 pCurrentObject->FileId.Vnode,
1212 pCurrentObject->FileId.Unique,
1215 try_return( ntStatus);
1218 SetFlag( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1221 AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
1223 else if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
1226 if( uniPathName.Length > 0)
1229 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1230 AFS_TRACE_LEVEL_ERROR,
1231 "AFSLocateNameEntry (FO: %p) Encountered file node %wZ FID %08lX-%08lX-%08lX-%08lX in path processing\n",
1233 &pDirEntry->NameInformation.FileName,
1234 pCurrentObject->FileId.Cell,
1235 pCurrentObject->FileId.Volume,
1236 pCurrentObject->FileId.Vnode,
1237 pCurrentObject->FileId.Unique);
1239 // The proper error code to return would be STATUS_OBJECT_PATH_INVALID because
1240 // one of the components of the path is not a directory. However, returning
1241 // that error prevents IIS 7 and 7.5 from being able to serve data out of AFS.
1242 // Instead IIS insists on treating the target file as if it is a directory containing
1243 // a potential web.config file. NTFS and LanMan return STATUS_OBJECT_PATH_NOT_FOUND.
1244 // AFS will follow suit.
1246 ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1251 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1252 AFS_TRACE_LEVEL_VERBOSE,
1253 "AFSLocateNameEntry (FO: %p) Returning file %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1255 &pDirEntry->NameInformation.FileName,
1256 pCurrentObject->FileId.Cell,
1257 pCurrentObject->FileId.Volume,
1258 pCurrentObject->FileId.Vnode,
1259 pCurrentObject->FileId.Unique);
1262 // Pass back the directory entries
1265 *OutParentDirectoryCB = pParentDirEntry;
1267 pParentDirEntry = NULL;
1269 *OutDirectoryCB = pDirEntry;
1273 *OutVolumeCB = pCurrentVolume;
1275 *OutVolumeReferenceReason = VolumeReferenceReason;
1277 bReleaseCurrentVolume = FALSE;
1279 *RootPathName = uniFullPathName;
1282 try_return( ntStatus);
1286 // If we are at the end of the processing, set our returned information and get out
1289 if( uniPathName.Length == 0)
1292 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1293 AFS_TRACE_LEVEL_VERBOSE,
1294 "AFSLocateNameEntry (FO: %p) Completed processing returning %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1296 &pDirEntry->NameInformation.FileName,
1297 pCurrentObject->FileId.Cell,
1298 pCurrentObject->FileId.Volume,
1299 pCurrentObject->FileId.Vnode,
1300 pCurrentObject->FileId.Unique);
1303 // Pass back the directory entries
1306 *OutParentDirectoryCB = pParentDirEntry;
1308 pParentDirEntry = NULL;
1310 *OutDirectoryCB = pDirEntry;
1314 *OutVolumeCB = pCurrentVolume;
1316 *OutVolumeReferenceReason = VolumeReferenceReason;
1318 bReleaseCurrentVolume = FALSE;
1320 *RootPathName = uniFullPathName;
1322 try_return( ntStatus);
1326 // We may have returned to the top of the while( TRUE)
1328 if( bSubstituteName &&
1329 uniSearchName.Buffer != NULL)
1332 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1334 bSubstituteName = FALSE;
1336 uniSearchName.Length = uniSearchName.MaximumLength = 0;
1337 uniSearchName.Buffer = NULL;
1340 ulSubstituteIndex = 1;
1342 ntStatus = STATUS_SUCCESS;
1345 // Get the next component name
1348 FsRtlDissectName( uniPathName,
1353 // Check for the . and .. in the path
1356 if( RtlCompareUnicodeString( &uniComponentName,
1361 uniPathName = uniRemainingPath;
1366 if( RtlCompareUnicodeString( &uniComponentName,
1371 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1372 AFS_TRACE_LEVEL_VERBOSE,
1373 "AFSLocateNameEntry (FO: %p) Backing up entry from %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1375 &pDirEntry->NameInformation.FileName,
1376 pCurrentObject->FileId.Cell,
1377 pCurrentObject->FileId.Volume,
1378 pCurrentObject->FileId.Vnode,
1379 pCurrentObject->FileId.Unique);
1382 // Need to back up one entry in the name array
1384 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1386 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1387 AFS_TRACE_LEVEL_VERBOSE,
1388 "AFSLocateNameEntry Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
1389 &pDirEntry->NameInformation.FileName,
1394 ASSERT( lCount >= 0);
1396 pDirEntry = AFSBackupEntry( NameArray);
1398 if( pDirEntry == NULL)
1401 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1402 AFS_TRACE_LEVEL_ERROR,
1403 "AFSLocateNameEntry AFSBackupEntry failed\n");
1405 try_return(ntStatus = STATUS_OBJECT_PATH_INVALID);
1408 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1410 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1411 AFS_TRACE_LEVEL_VERBOSE,
1412 "AFSLocateNameEntry Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
1413 &pDirEntry->NameInformation.FileName,
1418 if ( pParentDirEntry)
1421 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
1423 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1424 AFS_TRACE_LEVEL_VERBOSE,
1425 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1426 &pParentDirEntry->NameInformation.FileName,
1431 pParentDirEntry = NULL;
1434 if( !BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
1437 pParentDirEntry = AFSGetParentEntry( pNameArray);
1439 ASSERT( pParentDirEntry != pDirEntry);
1441 if ( pParentDirEntry)
1444 lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
1446 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1447 AFS_TRACE_LEVEL_VERBOSE,
1448 "AFSLocateNameEntry Increment count on %wZ DE %p Ccb %p Cnt %d\n",
1449 &pParentDirEntry->NameInformation.FileName,
1456 uniPathName = uniRemainingPath;
1462 // Update our pointers
1465 if ( pParentDirEntry)
1468 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
1470 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1471 AFS_TRACE_LEVEL_VERBOSE,
1472 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1473 &pParentDirEntry->NameInformation.FileName,
1479 pParentDirEntry = pDirEntry;
1483 uniSearchName = uniComponentName;
1485 while( pDirEntry == NULL)
1489 // If the SearchName contains @SYS then we perform the substitution.
1490 // If there is no substitution we give up.
1493 if( !bSubstituteName &&
1494 FsRtlIsNameInExpression( &uniSysName,
1500 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1501 AFS_TRACE_LEVEL_VERBOSE_2,
1502 "AFSLocateNameEntry (FO: %p) Processing @SYS substitution for %wZ Index %08lX\n",
1507 ntStatus = AFSSubstituteSysName( &uniComponentName,
1511 if ( NT_SUCCESS( ntStatus))
1514 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1515 AFS_TRACE_LEVEL_VERBOSE_2,
1516 "AFSLocateNameEntry (FO: %p) Located substitution %wZ for %wZ Index %08lX\n",
1523 // Go reparse the name again
1526 bSubstituteName = TRUE;
1528 ulSubstituteIndex++; // For the next entry, if needed
1530 continue; // while( pDirEntry == NULL)
1535 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1536 AFS_TRACE_LEVEL_ERROR,
1537 "AFSLocateNameEntry (FO: %p) Failed to locate substitute string for %wZ Index %08lX Status %08lX\n",
1543 if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
1547 // Pass back the directory entries
1550 *OutParentDirectoryCB = pParentDirEntry;
1552 pParentDirEntry = NULL;
1554 *OutDirectoryCB = NULL;
1556 *OutVolumeCB = pCurrentVolume;
1558 *OutVolumeReferenceReason = VolumeReferenceReason;
1560 bReleaseCurrentVolume = FALSE;
1562 if( ComponentName != NULL)
1565 *ComponentName = uniComponentName;
1568 *RootPathName = uniFullPathName;
1572 // We can't possibly have a pDirEntry since the lookup failed
1574 try_return( ntStatus);
1579 // Generate the CRC on the node and perform a case sensitive lookup
1582 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1583 AFS_TRACE_LEVEL_VERBOSE_2,
1584 "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case sensitive\n",
1588 ulCRC = AFSGenerateCRC( &uniSearchName,
1591 AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1594 AFSLocateCaseSensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
1598 if( pDirEntry == NULL)
1602 // Missed so perform a case insensitive lookup
1605 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1606 AFS_TRACE_LEVEL_VERBOSE_2,
1607 "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case insensitive\n",
1611 ulCRC = AFSGenerateCRC( &uniSearchName,
1614 AFSLocateCaseInsensitiveDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
1618 if( pDirEntry == NULL)
1622 // OK, if this component is a valid short name then try
1623 // a lookup in the short name tree
1626 if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
1627 RtlIsNameLegalDOS8Dot3( &uniSearchName,
1632 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1633 AFS_TRACE_LEVEL_VERBOSE_2,
1634 "AFSLocateNameEntry (FO: %p) Searching for entry %wZ short name\n",
1638 AFSLocateShortNameDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.ShortNameTree,
1643 if ( pDirEntry == NULL &&
1644 pParentDirEntry->ObjectInformation->VolumeCB == AFSGlobalRoot)
1648 // Check with the service to see if this is a valid cell name
1649 // that can be automatically resolved. Drop the shared TreeLock
1650 // since AFSCheckCellName must acquire it exclusively.
1653 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1655 ntStatus = AFSCheckCellName( AuthGroup,
1659 AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1663 if( pDirEntry == NULL)
1667 // If we substituted a name then reset our search name and try again
1670 if( bSubstituteName)
1673 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
1675 uniSearchName = uniComponentName;
1677 bSubstituteName = FALSE;
1679 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1681 continue; // while( pDirEntry == NULL)
1685 // Node name not found so get out
1688 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1690 if( uniRemainingPath.Length > 0)
1693 ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1695 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1696 AFS_TRACE_LEVEL_VERBOSE,
1697 "AFSLocateNameEntry (FO: %p) Returning path not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1700 pCurrentObject->FileId.Cell,
1701 pCurrentObject->FileId.Volume,
1702 pCurrentObject->FileId.Vnode,
1703 pCurrentObject->FileId.Unique);
1708 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
1710 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1711 AFS_TRACE_LEVEL_VERBOSE,
1712 "AFSLocateNameEntry (FO: %p) Returning name not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1715 pCurrentObject->FileId.Cell,
1716 pCurrentObject->FileId.Volume,
1717 pCurrentObject->FileId.Vnode,
1718 pCurrentObject->FileId.Unique);
1721 // Pass back the directory entries
1724 *OutParentDirectoryCB = pParentDirEntry;
1726 pParentDirEntry = NULL;
1728 *OutDirectoryCB = NULL;
1730 *OutVolumeCB = pCurrentVolume;
1732 *OutVolumeReferenceReason = VolumeReferenceReason;
1734 bReleaseCurrentVolume = FALSE;
1736 if( ComponentName != NULL)
1739 *ComponentName = uniComponentName;
1742 *RootPathName = uniFullPathName;
1745 try_return( ntStatus);
1752 // Here we have a match on the case insensitive lookup for the name. If there
1753 // Is more than one link entry for this node then fail the lookup request
1756 if( !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD) ||
1757 pDirEntry->CaseInsensitiveList.fLink != NULL)
1761 // Increment our dir entry ref count since we will decrement it on exit
1764 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1766 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1767 AFS_TRACE_LEVEL_VERBOSE,
1768 "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
1769 &pDirEntry->NameInformation.FileName,
1774 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1776 try_return(ntStatus = STATUS_OBJECT_NAME_COLLISION);
1781 if( pDirEntry != NULL)
1785 // If the verify flag is set on the parent and the current entry is deleted
1786 // revalidate the parent and search again.
1789 if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
1790 BooleanFlagOn( pParentDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
1793 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1795 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1796 AFS_TRACE_LEVEL_VERBOSE,
1797 "AFSLocateNameEntry (FO: %p) Verifying(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1799 &pParentDirEntry->NameInformation.FileName,
1800 pParentDirEntry->ObjectInformation->FileId.Cell,
1801 pParentDirEntry->ObjectInformation->FileId.Volume,
1802 pParentDirEntry->ObjectInformation->FileId.Vnode,
1803 pParentDirEntry->ObjectInformation->FileId.Unique);
1806 // Directory TreeLock should be exclusively held
1809 AFSAcquireExcl( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1812 ntStatus = AFSVerifyEntry( AuthGroup,
1815 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1817 if( !NT_SUCCESS( ntStatus))
1820 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1821 AFS_TRACE_LEVEL_ERROR,
1822 "AFSLocateNameEntry (FO: %p) Failed to verify(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1824 &pParentDirEntry->NameInformation.FileName,
1825 pParentDirEntry->ObjectInformation->FileId.Cell,
1826 pParentDirEntry->ObjectInformation->FileId.Volume,
1827 pParentDirEntry->ObjectInformation->FileId.Vnode,
1828 pParentDirEntry->ObjectInformation->FileId.Unique,
1831 try_return( ntStatus);
1834 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1835 AFS_TRACE_LEVEL_VERBOSE,
1836 "AFSLocateNameEntry (FO: %p) Reprocessing component %wZ in parent %wZ\n",
1839 &pParentDirEntry->NameInformation.FileName);
1848 // Increment our dir entry ref count
1851 lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
1853 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1854 AFS_TRACE_LEVEL_VERBOSE,
1855 "AFSLocateNameEntry Increment6 count on %wZ DE %p Ccb %p Cnt %d\n",
1856 &pDirEntry->NameInformation.FileName,
1862 AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1864 } // End while( pDirEntry == NULL)
1867 // If we have a dirEntry for this component, perform some basic validation on it
1870 if( pDirEntry != NULL &&
1871 BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
1874 pCurrentObject = pDirEntry->ObjectInformation;
1876 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1877 AFS_TRACE_LEVEL_ERROR,
1878 "AFSLocateNameEntry (FO: %p) Deleted entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1880 &pDirEntry->NameInformation.FileName,
1881 pCurrentObject->FileId.Cell,
1882 pCurrentObject->FileId.Volume,
1883 pCurrentObject->FileId.Vnode,
1884 pCurrentObject->FileId.Unique);
1887 // This entry was deleted through the invalidation call back so perform cleanup
1891 if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
1894 pParentObjectInfo = AFSFindObjectInfo( pCurrentObject->VolumeCB,
1895 &pCurrentObject->ParentFileId);
1898 ASSERT( pParentObjectInfo != NULL);
1900 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
1903 AFSAcquireExcl( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock,
1906 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
1908 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1909 AFS_TRACE_LEVEL_VERBOSE,
1910 "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
1911 &pDirEntry->NameInformation.FileName,
1916 ASSERT( lCount >= 0);
1921 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING|AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1922 AFS_TRACE_LEVEL_VERBOSE,
1923 "AFSLocateNameEntry Deleting dir entry %p (%p) for %wZ\n",
1926 &pDirEntry->NameInformation.FileName);
1929 // Remove and delete the directory entry from the parent list
1932 AFSDeleteDirEntry( pParentObjectInfo,
1935 AFSAcquireShared( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
1938 if( pCurrentObject->ObjectReferenceCount <= 0)
1941 if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
1944 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
1945 AFS_TRACE_LEVEL_VERBOSE,
1946 "AFSLocateNameEntry Removing object %p from volume tree\n",
1949 AFSRemoveHashEntry( &pCurrentObject->VolumeCB->ObjectInfoTree.TreeHead,
1950 &pCurrentObject->TreeEntry);
1952 ClearFlag( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
1956 AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
1961 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1962 AFS_TRACE_LEVEL_VERBOSE,
1963 "AFSLocateNameEntry Setting DELETE flag in dir entry %p for %wZ\n",
1965 &pDirEntry->NameInformation.FileName);
1967 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
1969 AFSRemoveNameEntry( pParentObjectInfo,
1973 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
1975 AFSReleaseResource( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock);
1977 AFSReleaseObjectInfo( &pParentObjectInfo);
1980 // We deleted the dir entry so check if there is any remaining portion
1981 // of the name to process.
1984 if( uniRemainingPath.Length > 0)
1987 ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
1989 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1990 AFS_TRACE_LEVEL_VERBOSE,
1991 "AFSLocateNameEntry (FO: %p) Returning path not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1994 pCurrentObject->FileId.Cell,
1995 pCurrentObject->FileId.Volume,
1996 pCurrentObject->FileId.Vnode,
1997 pCurrentObject->FileId.Unique);
2002 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
2004 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2005 AFS_TRACE_LEVEL_VERBOSE,
2006 "AFSLocateNameEntry (FO: %p) Returning name not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2009 pCurrentObject->FileId.Cell,
2010 pCurrentObject->FileId.Volume,
2011 pCurrentObject->FileId.Vnode,
2012 pCurrentObject->FileId.Unique);
2015 // Pass back the directory entries
2018 *OutParentDirectoryCB = pParentDirEntry;
2020 pParentDirEntry = NULL;
2022 *OutDirectoryCB = NULL;
2024 *OutVolumeCB = pCurrentVolume;
2026 *OutVolumeReferenceReason = VolumeReferenceReason;
2028 bReleaseCurrentVolume = FALSE;
2030 if( ComponentName != NULL)
2033 *ComponentName = uniComponentName;
2036 *RootPathName = uniFullPathName;
2040 if( ntStatus != STATUS_SUCCESS)
2043 try_return( ntStatus);
2047 // If we ended up substituting a name in the component then update
2048 // the full path and update the pointers
2051 if( bSubstituteName)
2054 BOOLEAN bRelativeOpen = FALSE;
2056 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2057 AFS_TRACE_LEVEL_VERBOSE_2,
2058 "AFSLocateNameEntry (FO: %p) Substituting %wZ into %wZ Index %08lX\n",
2064 if( FileObject != NULL &&
2065 FileObject->RelatedFileObject != NULL)
2068 bRelativeOpen = TRUE;
2072 // AFSSubstituteNameInPath will replace the uniFullPathName.Buffer
2073 // and free the prior Buffer contents but only if the fourth
2074 // parameter is TRUE.
2077 ntStatus = AFSSubstituteNameInPath( &uniFullPathName,
2082 bAllocatedSymLinkBuffer ||
2085 if( !NT_SUCCESS( ntStatus))
2088 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2089 AFS_TRACE_LEVEL_ERROR,
2090 "AFSLocateNameEntry (FO: %p) Failure to substitute %wZ into %wZ Index %08lX Status %08lX\n",
2097 try_return( ntStatus);
2101 // We have substituted a name into the buffer so if we do this again for this
2102 // path, we need to free up the buffer we allocated.
2105 bSubstitutedName = TRUE;
2109 // Update the search parameters
2112 uniPathName = uniRemainingPath;
2115 // Check if the is a SymLink entry but has no Target FileID or Name. In this
2116 // case it might be a DFS Link so let's go and evaluate it to be sure
2119 if( pCurrentObject->FileType == AFS_FILE_TYPE_SYMLINK &&
2120 ( pCurrentObject->TargetFileId.Vnode == 0 ||
2121 pDirEntry->NameInformation.TargetName.Length == 0))
2124 ntStatus = AFSValidateSymLink( AuthGroup,
2127 if( !NT_SUCCESS( ntStatus))
2130 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2131 AFS_TRACE_LEVEL_ERROR,
2132 "AFSLocateNameEntry (FO: %p) Failed to evaluate possible DFS Link %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2134 &pDirEntry->NameInformation.FileName,
2135 pCurrentObject->FileId.Cell,
2136 pCurrentObject->FileId.Volume,
2137 pCurrentObject->FileId.Vnode,
2138 pCurrentObject->FileId.Unique,
2141 try_return( ntStatus);
2146 // Update the name array
2149 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2150 AFS_TRACE_LEVEL_VERBOSE,
2151 "AFSLocateNameEntry (FO: %p) Inserting name array entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2153 &pDirEntry->NameInformation.FileName,
2154 pCurrentObject->FileId.Cell,
2155 pCurrentObject->FileId.Volume,
2156 pCurrentObject->FileId.Vnode,
2157 pCurrentObject->FileId.Unique);
2159 ntStatus = AFSInsertNextElement( pNameArray,
2162 if( !NT_SUCCESS( ntStatus))
2165 try_return( ntStatus);
2171 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2172 AFS_TRACE_LEVEL_VERBOSE,
2173 "AFSLocateNameEntry (FO: %p) Completed processing %wZ Status %08lX\n",
2178 if( ( !NT_SUCCESS( ntStatus) &&
2179 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND) ||
2180 ntStatus == STATUS_REPARSE)
2182 if( RootPathName->Buffer != uniFullPathName.Buffer)
2185 AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
2191 if( *OutParentDirectoryCB != NULL)
2194 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2195 AFS_TRACE_LEVEL_VERBOSE,
2196 "AFSLocateNameEntry Count on Parent %wZ DE %p Ccb %p Cnt %d\n",
2197 &(*OutParentDirectoryCB)->NameInformation.FileName,
2198 *OutParentDirectoryCB,
2200 (*OutParentDirectoryCB)->DirOpenReferenceCount);
2203 if( *OutDirectoryCB != NULL)
2206 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2207 AFS_TRACE_LEVEL_VERBOSE,
2208 "AFSLocateNameEntry Count on %wZ DE %p Ccb %p Cnt %d\n",
2209 &(*OutDirectoryCB)->NameInformation.FileName,
2212 (*OutDirectoryCB)->DirOpenReferenceCount);
2216 if( pDirEntry != NULL)
2219 lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
2221 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2222 AFS_TRACE_LEVEL_VERBOSE,
2223 "AFSLocateNameEntry Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
2224 &pDirEntry->NameInformation.FileName,
2229 ASSERT( lCount >= 0);
2232 if( pParentDirEntry != NULL)
2235 lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
2237 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2238 AFS_TRACE_LEVEL_VERBOSE,
2239 "AFSLocateNameEntry Decrement7 count on %wZ DE %p Ccb %p Cnt %d\n",
2240 &pParentDirEntry->NameInformation.FileName,
2245 ASSERT( lCount >= 0);
2248 if( bReleaseCurrentVolume)
2251 ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
2253 lCount = AFSVolumeDecrement( pCurrentVolume,
2254 VolumeReferenceReason);
2256 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
2257 AFS_TRACE_LEVEL_VERBOSE,
2258 "AFSLocateNameEntry Decrement7 count on volume %p Reason %u Cnt %d\n",
2260 VolumeReferenceReason,
2263 bReleaseCurrentVolume = FALSE;
2266 if( bSubstituteName &&
2267 uniSearchName.Buffer != NULL)
2270 AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
2278 AFSCreateDirEntry( IN GUID *AuthGroup,
2279 IN AFSObjectInfoCB *ParentObjectInfo,
2280 IN AFSDirectoryCB *ParentDirCB,
2281 IN PUNICODE_STRING FileName,
2282 IN PUNICODE_STRING ComponentName,
2283 IN ULONG Attributes,
2284 IN OUT AFSDirectoryCB **DirEntry)
2287 UNREFERENCED_PARAMETER(FileName);
2288 NTSTATUS ntStatus = STATUS_SUCCESS;
2289 AFSDirectoryCB *pDirNode = NULL, *pExistingDirNode = NULL;
2290 LARGE_INTEGER liFileSize = {0,0};
2296 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2297 AFS_TRACE_LEVEL_VERBOSE_2,
2298 "AFSCreateDirEntry Creating dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX\n",
2299 &ParentDirCB->NameInformation.FileName,
2300 ParentObjectInfo->FileId.Cell,
2301 ParentObjectInfo->FileId.Volume,
2302 ParentObjectInfo->FileId.Vnode,
2303 ParentObjectInfo->FileId.Unique,
2308 // OK, before inserting the node into the parent tree, issue
2309 // the request to the service for node creation
2310 // We will need to drop the lock on the parent node since the create
2311 // could cause a callback into the file system to invalidate it's cache
2314 ntStatus = AFSNotifyFileCreate( AuthGroup,
2322 // If the returned status is STATUS_REPARSE then the entry exists
2323 // and we raced, get out.
2325 if( ntStatus == STATUS_REPARSE)
2328 *DirEntry = pDirNode;
2330 try_return( ntStatus = STATUS_SUCCESS);
2333 if( !NT_SUCCESS( ntStatus))
2336 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2337 AFS_TRACE_LEVEL_ERROR,
2338 "AFSCreateDirEntry Failed to create dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX Status %08lX\n",
2339 &ParentDirCB->NameInformation.FileName,
2340 ParentObjectInfo->FileId.Cell,
2341 ParentObjectInfo->FileId.Volume,
2342 ParentObjectInfo->FileId.Vnode,
2343 ParentObjectInfo->FileId.Unique,
2348 try_return( ntStatus);
2352 // If AFSNotifyFileCreate returns pDirNode != NULL, then its
2353 // DirOpenReferenceCount is held.
2356 AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2360 // Before attempting to insert the new entry, check if we need to validate the parent
2363 if( BooleanFlagOn( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
2366 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2367 AFS_TRACE_LEVEL_VERBOSE,
2368 "AFSCreateDirEntry Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2369 &ParentDirCB->NameInformation.FileName,
2370 ParentObjectInfo->FileId.Cell,
2371 ParentObjectInfo->FileId.Volume,
2372 ParentObjectInfo->FileId.Vnode,
2373 ParentObjectInfo->FileId.Unique);
2375 ntStatus = AFSVerifyEntry( AuthGroup,
2378 if( !NT_SUCCESS( ntStatus))
2381 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2382 AFS_TRACE_LEVEL_ERROR,
2383 "AFSCreateDirEntry Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2384 &ParentDirCB->NameInformation.FileName,
2385 ParentObjectInfo->FileId.Cell,
2386 ParentObjectInfo->FileId.Volume,
2387 ParentObjectInfo->FileId.Vnode,
2388 ParentObjectInfo->FileId.Unique,
2391 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2393 try_return( ntStatus);
2398 // Check for the entry in the event we raced with some other thread
2401 AFSLocateCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2402 (ULONG)pDirNode->CaseSensitiveTreeEntry.HashIndex,
2405 if( pExistingDirNode != NULL)
2407 if (AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
2408 &pExistingDirNode->ObjectInformation->FileId))
2411 if ( pExistingDirNode != pDirNode)
2414 lCount = InterlockedDecrement( &pDirNode->DirOpenReferenceCount);
2416 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2417 AFS_TRACE_LEVEL_VERBOSE,
2418 "AFSCreateDirEntry Decrement count on %wZ DE %p Cnt %d\n",
2419 &pDirNode->NameInformation.FileName,
2423 AFSDeleteDirEntry( ParentObjectInfo,
2426 lCount = InterlockedIncrement( &pExistingDirNode->DirOpenReferenceCount);
2428 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2429 AFS_TRACE_LEVEL_VERBOSE,
2430 "AFSCreateDirEntry Increment count on %wZ DE %p Cnt %d\n",
2431 &pExistingDirNode->NameInformation.FileName,
2435 *DirEntry = pExistingDirNode;
2438 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2440 try_return( ntStatus = STATUS_SUCCESS);
2446 // Need to tear down this entry and rebuild it below
2449 if( pExistingDirNode->DirOpenReferenceCount <= 0)
2452 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2453 AFS_TRACE_LEVEL_VERBOSE,
2454 "AFSCreateDirEntry Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2456 &pExistingDirNode->NameInformation.FileName,
2457 pExistingDirNode->ObjectInformation->FileId.Cell,
2458 pExistingDirNode->ObjectInformation->FileId.Volume,
2459 pExistingDirNode->ObjectInformation->FileId.Vnode,
2460 pExistingDirNode->ObjectInformation->FileId.Unique,
2461 pDirNode->ObjectInformation->FileId.Cell,
2462 pDirNode->ObjectInformation->FileId.Volume,
2463 pDirNode->ObjectInformation->FileId.Vnode,
2464 pDirNode->ObjectInformation->FileId.Unique);
2466 AFSDeleteDirEntry( ParentObjectInfo,
2472 SetFlag( pExistingDirNode->Flags, AFS_DIR_ENTRY_DELETED);
2474 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2475 AFS_TRACE_LEVEL_VERBOSE,
2476 "AFSCreateDirEntry Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
2478 &pExistingDirNode->NameInformation.FileName,
2479 pExistingDirNode->ObjectInformation->FileId.Cell,
2480 pExistingDirNode->ObjectInformation->FileId.Volume,
2481 pExistingDirNode->ObjectInformation->FileId.Vnode,
2482 pExistingDirNode->ObjectInformation->FileId.Unique,
2483 pDirNode->ObjectInformation->FileId.Cell,
2484 pDirNode->ObjectInformation->FileId.Volume,
2485 pDirNode->ObjectInformation->FileId.Vnode,
2486 pDirNode->ObjectInformation->FileId.Unique);
2488 AFSRemoveNameEntry( ParentObjectInfo,
2494 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2495 AFS_TRACE_LEVEL_VERBOSE_2,
2496 "AFSCreateDirEntry Inserting dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ\n",
2497 &ParentDirCB->NameInformation.FileName,
2498 ParentObjectInfo->FileId.Cell,
2499 ParentObjectInfo->FileId.Volume,
2500 ParentObjectInfo->FileId.Vnode,
2501 ParentObjectInfo->FileId.Unique,
2505 // Insert the directory node
2508 AFSInsertDirectoryNode( ParentObjectInfo,
2513 // Pass back the dir entry
2516 *DirEntry = pDirNode;
2518 AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2529 AFSInsertDirectoryNode( IN AFSObjectInfoCB *ParentObjectInfo,
2530 IN AFSDirectoryCB *DirEntry,
2531 IN BOOLEAN InsertInEnumList)
2539 ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2542 // Insert the node into the directory node tree
2545 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2546 AFS_TRACE_LEVEL_VERBOSE,
2547 "AFSInsertDirectoryNode Insert DE %p for %wZ Clearing NOT_IN flag\n",
2549 &DirEntry->NameInformation.FileName);
2551 ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
2553 if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead == NULL)
2556 ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = DirEntry;
2558 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2559 AFS_TRACE_LEVEL_VERBOSE,
2560 "AFSInsertDirectoryNode Insert DE %p to head of case sensitive tree for %wZ\n",
2562 &DirEntry->NameInformation.FileName);
2567 AFSInsertCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2570 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2571 AFS_TRACE_LEVEL_VERBOSE,
2572 "AFSInsertDirectoryNode Insert DE %p to case sensitive tree for %wZ\n",
2574 &DirEntry->NameInformation.FileName);
2577 if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead == NULL)
2580 ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = DirEntry;
2582 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
2584 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2585 AFS_TRACE_LEVEL_VERBOSE,
2586 "AFSInsertDirectoryNode Insert DE %p to head of case insensitive tree for %wZ\n",
2588 &DirEntry->NameInformation.FileName);
2593 AFSInsertCaseInsensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2596 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2597 AFS_TRACE_LEVEL_VERBOSE,
2598 "AFSInsertDirectoryNode Insert DE %p to case insensitive tree for %wZ\n",
2600 &DirEntry->NameInformation.FileName);
2604 // Into the shortname tree
2607 if( DirEntry->Type.Data.ShortNameTreeEntry.HashIndex != 0)
2610 if( ParentObjectInfo->Specific.Directory.ShortNameTree == NULL)
2613 ParentObjectInfo->Specific.Directory.ShortNameTree = DirEntry;
2615 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2616 AFS_TRACE_LEVEL_VERBOSE,
2617 "AFSInsertDirectoryNode Insert DE %p to head of shortname tree for %wZ\n",
2619 &DirEntry->NameInformation.FileName);
2621 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2626 if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ParentObjectInfo->Specific.Directory.ShortNameTree,
2629 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2630 AFS_TRACE_LEVEL_VERBOSE,
2631 "AFSInsertDirectoryNode Failed to insert DE %p to shortname tree for %wZ\n",
2633 &DirEntry->NameInformation.FileName);
2637 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
2639 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2640 AFS_TRACE_LEVEL_VERBOSE,
2641 "AFSInsertDirectoryNode Insert DE %p to shortname tree for %wZ\n",
2643 &DirEntry->NameInformation.FileName);
2648 if( InsertInEnumList)
2652 // And insert the node into the directory list
2655 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2656 AFS_TRACE_LEVEL_VERBOSE,
2657 "AFSInsertDirectoryNode Inserting entry %p %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2659 &DirEntry->NameInformation.FileName,
2660 DirEntry->ObjectInformation->FileId.Cell,
2661 DirEntry->ObjectInformation->FileId.Volume,
2662 DirEntry->ObjectInformation->FileId.Vnode,
2663 DirEntry->ObjectInformation->FileId.Unique);
2665 if( ParentObjectInfo->Specific.Directory.DirectoryNodeListHead == NULL)
2668 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = DirEntry;
2673 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail->ListEntry.fLink = (void *)DirEntry;
2675 DirEntry->ListEntry.bLink = (void *)ParentObjectInfo->Specific.Directory.DirectoryNodeListTail;
2678 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = DirEntry;
2680 SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2682 lCount = InterlockedIncrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2684 AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2685 AFS_TRACE_LEVEL_VERBOSE,
2686 "AFSInsertDirectoryNode Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2687 &DirEntry->NameInformation.FileName,
2689 ParentObjectInfo->FileId.Cell,
2690 ParentObjectInfo->FileId.Volume,
2691 ParentObjectInfo->FileId.Vnode,
2692 ParentObjectInfo->FileId.Unique);
2700 AFSDeleteDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
2701 IN AFSDirectoryCB *DirEntry)
2709 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2710 AFS_TRACE_LEVEL_VERBOSE,
2711 "AFSDeleteDirEntry Deleting dir entry in parent %p Entry %p %wZ FID %08lX-%08lX-%08lX-%08lX RefCount %d\n",
2714 &DirEntry->NameInformation.FileName,
2715 DirEntry->ObjectInformation->FileId.Cell,
2716 DirEntry->ObjectInformation->FileId.Volume,
2717 DirEntry->ObjectInformation->FileId.Vnode,
2718 DirEntry->ObjectInformation->FileId.Unique,
2719 DirEntry->DirOpenReferenceCount);
2721 ASSERT( DirEntry->DirOpenReferenceCount == 0);
2723 AFSRemoveDirNodeFromParent( ParentObjectInfo,
2728 // Free up the name buffer if it was reallocated
2731 if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
2734 AFSExFreePoolWithTag( DirEntry->NameInformation.FileName.Buffer, 0);
2737 if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
2740 AFSExFreePoolWithTag( DirEntry->NameInformation.TargetName.Buffer, 0);
2744 // Dereference the object for this dir entry
2747 lCount = AFSObjectInfoDecrement( DirEntry->ObjectInformation,
2748 AFS_OBJECT_REFERENCE_DIRENTRY);
2750 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2751 AFS_TRACE_LEVEL_VERBOSE,
2752 "AFSDeleteDirEntry Decrement count on object %p Cnt %d\n",
2753 DirEntry->ObjectInformation,
2756 if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_DELETED) &&
2757 DirEntry->ObjectInformation->Links == 0)
2760 SetFlag( DirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED);
2763 ExDeleteResourceLite( &DirEntry->NonPaged->Lock);
2765 AFSExFreePoolWithTag( DirEntry->NonPaged, AFS_DIR_ENTRY_NP_TAG);
2768 // Free up the dir entry
2771 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
2772 AFS_TRACE_LEVEL_VERBOSE,
2773 "AFSDeleteDirEntry AFS_DIR_ENTRY_TAG deallocating %p\n",
2776 AFSExFreePoolWithTag( DirEntry, AFS_DIR_ENTRY_TAG);
2781 AFSRemoveDirNodeFromParent( IN AFSObjectInfoCB *ParentObjectInfo,
2782 IN AFSDirectoryCB *DirEntry,
2783 IN BOOLEAN RemoveFromEnumList)
2786 NTSTATUS ntStatus = STATUS_SUCCESS;
2793 ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
2795 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
2796 AFS_TRACE_LEVEL_VERBOSE,
2797 "AFSRemoveDirNodeFromParent Removing DirEntry %p %wZ FID %08lX-%08lX-%08lX-%08lX from Parent %p\n",
2799 &DirEntry->NameInformation.FileName,
2800 DirEntry->ObjectInformation->FileId.Cell,
2801 DirEntry->ObjectInformation->FileId.Volume,
2802 DirEntry->ObjectInformation->FileId.Vnode,
2803 DirEntry->ObjectInformation->FileId.Unique,
2806 if( !BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
2809 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
2810 AFS_TRACE_LEVEL_VERBOSE,
2811 "AFSRemoveDirNodeFromParent Removing DirEntry %p name %wZ\n",
2813 &DirEntry->NameInformation.FileName);
2815 AFSRemoveNameEntry( ParentObjectInfo,
2821 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
2822 AFS_TRACE_LEVEL_VERBOSE,
2823 "AFSRemoveDirNodeFromParent DE %p for %wZ NOT removing entry due to flag set\n",
2825 &DirEntry->NameInformation.FileName);
2829 if( RemoveFromEnumList &&
2830 BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST))
2834 // And remove the entry from the enumeration list
2837 if( DirEntry->ListEntry.fLink == NULL)
2840 ParentObjectInfo->Specific.Directory.DirectoryNodeListTail = (AFSDirectoryCB *)DirEntry->ListEntry.bLink;
2845 ((AFSDirectoryCB *)DirEntry->ListEntry.fLink)->ListEntry.bLink = DirEntry->ListEntry.bLink;
2848 if( DirEntry->ListEntry.bLink == NULL)
2851 ParentObjectInfo->Specific.Directory.DirectoryNodeListHead = (AFSDirectoryCB *)DirEntry->ListEntry.fLink;
2856 ((AFSDirectoryCB *)DirEntry->ListEntry.bLink)->ListEntry.fLink = DirEntry->ListEntry.fLink;
2859 ASSERT( ParentObjectInfo->Specific.Directory.DirectoryNodeCount > 0);
2861 lCount = InterlockedDecrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
2863 ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
2865 AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
2866 AFS_TRACE_LEVEL_VERBOSE,
2867 "AFSRemoveDirNodeFromParent Removing entry %wZ Dec Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
2868 &DirEntry->NameInformation.FileName,
2870 ParentObjectInfo->FileId.Cell,
2871 ParentObjectInfo->FileId.Volume,
2872 ParentObjectInfo->FileId.Vnode,
2873 ParentObjectInfo->FileId.Unique);
2875 DirEntry->ListEntry.fLink = NULL;
2876 DirEntry->ListEntry.bLink = NULL;
2884 AFSFixupTargetName( IN OUT PUNICODE_STRING FileName,
2885 IN OUT PUNICODE_STRING TargetFileName)
2888 NTSTATUS ntStatus = STATUS_SUCCESS;
2889 UNICODE_STRING uniFileName;
2895 // We will process backwards from the end of the name looking
2896 // for the first \ we encounter
2899 uniFileName.Length = FileName->Length;
2900 uniFileName.MaximumLength = FileName->MaximumLength;
2902 uniFileName.Buffer = FileName->Buffer;
2907 if( uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
2911 // Subtract one more character off of the filename if it is not the root
2914 if( uniFileName.Length > sizeof( WCHAR))
2917 uniFileName.Length -= sizeof( WCHAR);
2921 // Now build up the target name
2924 TargetFileName->Length = FileName->Length - uniFileName.Length;
2927 // If we are not on the root then fixup the name
2930 if( uniFileName.Length > sizeof( WCHAR))
2933 TargetFileName->Length -= sizeof( WCHAR);
2935 TargetFileName->Buffer = &uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) + 1];
2940 TargetFileName->Buffer = &uniFileName.Buffer[ uniFileName.Length/sizeof( WCHAR)];
2944 // Fixup the passed back filename length
2947 FileName->Length = uniFileName.Length;
2949 TargetFileName->MaximumLength = TargetFileName->Length;
2954 uniFileName.Length -= sizeof( WCHAR);
2962 AFSParseName( IN PIRP Irp,
2964 OUT PUNICODE_STRING FileName,
2965 OUT PUNICODE_STRING ParsedFileName,
2966 OUT PUNICODE_STRING RootFileName,
2967 OUT ULONG *ParseFlags,
2968 OUT AFSVolumeCB **VolumeCB,
2969 OUT AFSDirectoryCB **ParentDirectoryCB,
2970 OUT AFSNameArrayHdr **NameArray)
2973 NTSTATUS ntStatus = STATUS_SUCCESS;
2974 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2975 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2976 UNICODE_STRING uniFullName, uniComponentName, uniRemainingPath;
2978 AFSDirectoryCB *pDirEntry = NULL;
2979 USHORT usIndex = 0, usDriveIndex = 0;
2980 AFSCcb *pRelatedCcb = NULL;
2981 AFSNameArrayHdr *pNameArray = NULL, *pRelatedNameArray = NULL;
2982 USHORT usComponentIndex = 0;
2983 USHORT usComponentLength = 0;
2984 AFSVolumeCB *pVolumeCB = NULL;
2985 AFSFcb *pRelatedFcb = NULL;
2986 BOOLEAN bReleaseTreeLock = FALSE;
2987 BOOLEAN bIsAllShare = FALSE;
2994 // Indicate we are opening a root ...
2997 *ParseFlags = AFS_PARSE_FLAG_ROOT_ACCESS;
2999 *ParentDirectoryCB = NULL;
3001 if( pIrpSp->FileObject->RelatedFileObject != NULL)
3004 pRelatedFcb = (AFSFcb *)pIrpSp->FileObject->RelatedFileObject->FsContext;
3006 pRelatedCcb = (AFSCcb *)pIrpSp->FileObject->RelatedFileObject->FsContext2;
3008 pRelatedNameArray = pRelatedCcb->NameArray;
3010 uniFullName = pIrpSp->FileObject->FileName;
3012 ASSERT( pRelatedFcb != NULL);
3015 // No wild cards in the name
3018 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3019 AFS_TRACE_LEVEL_VERBOSE_2,
3020 "AFSParseName (%p) Relative open for %wZ FID %08lX-%08lX-%08lX-%08lX component %wZ\n",
3022 &pRelatedCcb->DirectoryCB->NameInformation.FileName,
3023 pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Cell,
3024 pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Volume,
3025 pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
3026 pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Unique,
3029 if( FsRtlDoesNameContainWildCards( &uniFullName))
3032 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3033 AFS_TRACE_LEVEL_ERROR,
3034 "AFSParseName (%p) Component %wZ contains wild cards\n",
3038 try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3041 pVolumeCB = pRelatedFcb->ObjectInformation->VolumeCB;
3043 pDirEntry = pRelatedCcb->DirectoryCB;
3045 *FileName = pIrpSp->FileObject->FileName;
3048 // Grab the root node while checking state
3051 AFSAcquireShared( pVolumeCB->VolumeLock,
3054 if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
3055 BooleanFlagOn( pVolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE))
3059 // The volume has been taken off line so fail the access
3062 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3063 AFS_TRACE_LEVEL_ERROR,
3064 "AFSParseName (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
3066 pVolumeCB->ObjectInformation.FileId.Cell,
3067 pVolumeCB->ObjectInformation.FileId.Volume);
3069 AFSReleaseResource( pVolumeCB->VolumeLock);
3071 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
3074 if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
3077 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3078 AFS_TRACE_LEVEL_VERBOSE,
3079 "AFSParseName (%p) Verifying root of volume %08lX:%08lX\n",
3081 pVolumeCB->ObjectInformation.FileId.Cell,
3082 pVolumeCB->ObjectInformation.FileId.Volume);
3084 ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
3087 if( !NT_SUCCESS( ntStatus))
3090 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3091 AFS_TRACE_LEVEL_ERROR,
3092 "AFSParseName (%p) Failed verification of root Status %08lX\n",
3096 AFSReleaseResource( pVolumeCB->VolumeLock);
3098 try_return( ntStatus);
3102 AFSReleaseResource( pVolumeCB->VolumeLock);
3104 if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
3107 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3108 AFS_TRACE_LEVEL_VERBOSE,
3109 "AFSParseName (%p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3111 &pDirEntry->NameInformation.FileName,
3112 pDirEntry->ObjectInformation->FileId.Cell,
3113 pDirEntry->ObjectInformation->FileId.Volume,
3114 pDirEntry->ObjectInformation->FileId.Vnode,
3115 pDirEntry->ObjectInformation->FileId.Unique);
3118 // Directory TreeLock should be exclusively held
3121 AFSAcquireExcl( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
3124 ntStatus = AFSVerifyEntry( AuthGroup,
3127 AFSReleaseResource( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
3129 if( !NT_SUCCESS( ntStatus))
3132 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3133 AFS_TRACE_LEVEL_VERBOSE,
3134 "AFSParseName (%p) Failed verification of parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3136 &pDirEntry->NameInformation.FileName,
3137 pDirEntry->ObjectInformation->FileId.Cell,
3138 pDirEntry->ObjectInformation->FileId.Volume,
3139 pDirEntry->ObjectInformation->FileId.Vnode,
3140 pDirEntry->ObjectInformation->FileId.Unique,
3143 try_return( ntStatus);
3148 // Create our full path name buffer
3151 uniFullName.MaximumLength = pRelatedCcb->FullFileName.Length +
3153 pIrpSp->FileObject->FileName.Length +
3156 uniFullName.Length = 0;
3158 uniFullName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
3159 uniFullName.MaximumLength,
3160 AFS_NAME_BUFFER_THREE_TAG);
3162 if( uniFullName.Buffer == NULL)
3165 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3166 AFS_TRACE_LEVEL_ERROR,
3167 "AFSParseName (%p) Failed to allocate full name buffer\n",
3170 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3173 RtlZeroMemory( uniFullName.Buffer,
3174 uniFullName.MaximumLength);
3176 RtlCopyMemory( uniFullName.Buffer,
3177 pRelatedCcb->FullFileName.Buffer,
3178 pRelatedCcb->FullFileName.Length);
3180 uniFullName.Length = pRelatedCcb->FullFileName.Length;
3182 usComponentIndex = (USHORT)(uniFullName.Length/sizeof( WCHAR));
3184 usComponentLength = pIrpSp->FileObject->FileName.Length;
3186 if( uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
3187 pIrpSp->FileObject->FileName.Length > 0 &&
3188 pIrpSp->FileObject->FileName.Buffer[ 0] != L'\\' &&
3189 pIrpSp->FileObject->FileName.Buffer[ 0] != L':')
3192 uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR))] = L'\\';
3194 uniFullName.Length += sizeof( WCHAR);
3196 usComponentLength += sizeof( WCHAR);
3199 if( pIrpSp->FileObject->FileName.Length > 0)
3202 RtlCopyMemory( &uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)],
3203 pIrpSp->FileObject->FileName.Buffer,
3204 pIrpSp->FileObject->FileName.Length);
3206 uniFullName.Length += pIrpSp->FileObject->FileName.Length;
3209 *RootFileName = uniFullName;
3212 // We populate up to the current parent
3215 if( pRelatedNameArray == NULL)
3219 // Init and populate our name array
3222 pNameArray = AFSInitNameArray( NULL,
3225 if( pNameArray == NULL)
3228 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3229 AFS_TRACE_LEVEL_VERBOSE,
3230 "AFSParseName (%p) Failed to initialize name array\n",
3233 AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3235 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3238 ntStatus = AFSPopulateNameArray( pNameArray,
3240 pRelatedCcb->DirectoryCB);
3246 // Init and populate our name array
3249 pNameArray = AFSInitNameArray( NULL,
3250 pRelatedNameArray->MaxElementCount);
3252 if( pNameArray == NULL)
3255 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3256 AFS_TRACE_LEVEL_VERBOSE,
3257 "AFSParseName (%p) Failed to initialize name array\n",
3260 AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3262 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3265 ntStatus = AFSPopulateNameArrayFromRelatedArray( pNameArray,
3267 pRelatedCcb->DirectoryCB);
3270 if( !NT_SUCCESS( ntStatus))
3273 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3274 AFS_TRACE_LEVEL_VERBOSE,
3275 "AFSParseName (%p) Failed to populate name array\n",
3278 AFSExFreePoolWithTag( uniFullName.Buffer, 0);
3280 try_return( ntStatus);
3283 ParsedFileName->Length = usComponentLength;
3284 ParsedFileName->MaximumLength = uniFullName.MaximumLength;
3286 ParsedFileName->Buffer = &uniFullName.Buffer[ usComponentIndex];
3289 // Indicate to caller that RootFileName must be freed
3292 SetFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
3294 *NameArray = pNameArray;
3297 // Increment our volume reference count
3300 lCount = AFSVolumeIncrement( pVolumeCB,
3301 AFS_VOLUME_REFERENCE_PARSE_NAME);
3303 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
3304 AFS_TRACE_LEVEL_VERBOSE,
3305 "AFSParseName Increment count on volume %p Cnt %d\n",
3309 *VolumeCB = pVolumeCB;
3311 *ParentDirectoryCB = pDirEntry;
3313 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3314 AFS_TRACE_LEVEL_VERBOSE_2,
3315 "AFSParseName (%p) Returning full name %wZ\n",
3319 try_return( ntStatus);
3323 // No wild cards in the name
3326 uniFullName = pIrpSp->FileObject->FileName;
3328 if( FsRtlDoesNameContainWildCards( &uniFullName) ||
3329 uniFullName.Length < AFSServerName.Length)
3332 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3333 AFS_TRACE_LEVEL_ERROR,
3334 "AFSParseName (%p) Name %wZ contains wild cards or too short\n",
3338 try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3342 // The name is a fully qualified name. Parse out the server/share names and
3343 // point to the root qualified name
3344 // First thing is to locate the server name
3347 FsRtlDissectName( uniFullName,
3351 uniFullName = uniRemainingPath;
3354 // This component is the server name we are serving
3357 if( RtlCompareUnicodeString( &uniComponentName,
3363 // Drive letter based name?
3366 uniFullName = pIrpSp->FileObject->FileName;
3368 while( usIndex < uniFullName.Length/sizeof( WCHAR))
3371 if( uniFullName.Buffer[ usIndex] == L':')
3374 uniFullName.Buffer = &uniFullName.Buffer[ usIndex + 2];
3376 uniFullName.Length -= (usIndex + 2) * sizeof( WCHAR);
3378 usDriveIndex = usIndex - 1;
3387 // Do we have the right server name now?
3390 FsRtlDissectName( uniFullName,
3394 uniFullName = uniRemainingPath;
3397 // This component is the server name we are serving
3400 if( RtlCompareUnicodeString( &uniComponentName,
3405 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3406 AFS_TRACE_LEVEL_ERROR,
3407 "AFSParseName (%p) Name %wZ does not have server name\n",
3409 &pIrpSp->FileObject->FileName);
3411 try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
3415 // Validate this drive letter is actively mapped
3418 if( usDriveIndex > 0 &&
3419 !AFSIsDriveMapped( pIrpSp->FileObject->FileName.Buffer[ usDriveIndex]))
3422 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3423 AFS_TRACE_LEVEL_ERROR,
3424 "AFSParseName (%p) Name %wZ contains invalid drive mapping\n",
3426 &pIrpSp->FileObject->FileName);
3428 try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
3432 if( FsRtlDoesNameContainWildCards( &uniFullName))
3435 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3436 AFS_TRACE_LEVEL_ERROR,
3437 "AFSParseName (%p) Component %wZ contains wild cards\n",
3441 try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3444 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3445 AFS_TRACE_LEVEL_VERBOSE_2,
3446 "AFSParseName (%p) Processing full name %wZ\n",
3450 if( uniFullName.Length > 0 &&
3451 uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] == L'\\')
3454 uniFullName.Length -= sizeof( WCHAR);
3458 // Be sure we are online and ready to go
3461 AFSAcquireShared( AFSGlobalRoot->VolumeLock,
3464 if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
3465 BooleanFlagOn( AFSGlobalRoot->Flags, AFS_VOLUME_FLAGS_OFFLINE))
3469 // The volume has been taken off line so fail the access
3472 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3473 AFS_TRACE_LEVEL_ERROR,
3474 "AFSParseName (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
3476 AFSGlobalRoot->ObjectInformation.FileId.Cell,
3477 AFSGlobalRoot->ObjectInformation.FileId.Volume);
3479 AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3481 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
3484 if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
3487 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3488 AFS_TRACE_LEVEL_VERBOSE,
3489 "AFSParseName (%p) Verifying root of volume %08lX:%08lX\n",
3491 AFSGlobalRoot->ObjectInformation.FileId.Cell,
3492 AFSGlobalRoot->ObjectInformation.FileId.Volume);
3494 ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
3497 if( !NT_SUCCESS( ntStatus))
3500 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3501 AFS_TRACE_LEVEL_ERROR,
3502 "AFSParseName (%p) Failed verification of root Status %08lX\n",
3506 AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3508 try_return( ntStatus);
3512 AFSReleaseResource( AFSGlobalRoot->VolumeLock);
3514 if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
3517 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3518 AFS_TRACE_LEVEL_VERBOSE,
3519 "AFSParseName (%p) Enumerating global root of volume %08lX:%08lX\n",
3521 AFSGlobalRoot->ObjectInformation.FileId.Cell,
3522 AFSGlobalRoot->ObjectInformation.FileId.Volume);
3524 ntStatus = AFSEnumerateGlobalRoot( AuthGroup);
3526 if( !NT_SUCCESS( ntStatus))
3529 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3530 AFS_TRACE_LEVEL_ERROR,
3531 "AFSParseName (%p) Failed enumeraiton of root Status %08lX\n",
3535 try_return( ntStatus);
3540 // Check for the \\Server access and return it as though it were \\Server\Globalroot
3543 if( uniRemainingPath.Buffer == NULL ||
3544 ( uniRemainingPath.Length == sizeof( WCHAR) &&
3545 uniRemainingPath.Buffer[ 0] == L'\\'))
3548 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3549 AFS_TRACE_LEVEL_VERBOSE_2,
3550 "AFSParseName (%p) Returning global root access\n",
3553 lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3555 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3556 AFS_TRACE_LEVEL_VERBOSE,
3557 "AFSParseName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
3558 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3559 AFSGlobalRoot->DirectoryCB,
3565 FileName->Length = 0;
3566 FileName->MaximumLength = 0;
3567 FileName->Buffer = NULL;
3569 try_return( ntStatus = STATUS_SUCCESS);
3572 *RootFileName = uniFullName;
3575 // Include the starting \ in the root name
3578 if( RootFileName->Buffer[ 0] != L'\\')
3580 RootFileName->Buffer--;
3581 RootFileName->Length += sizeof( WCHAR);
3582 RootFileName->MaximumLength += sizeof( WCHAR);
3586 // Get the 'share' name
3589 FsRtlDissectName( uniFullName,
3593 if( FsRtlDoesNameContainWildCards( &uniFullName))
3596 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3597 AFS_TRACE_LEVEL_ERROR,
3598 "AFSParseName (%p) Component %wZ contains wild cards\n",
3602 try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
3606 // If this is the ALL access then perform some additional processing
3609 if( uniComponentName.Length == 0 ||
3610 RtlCompareUnicodeString( &uniComponentName,
3618 // If there is nothing else then get out
3621 if( uniRemainingPath.Buffer == NULL ||
3622 uniRemainingPath.Length == 0 ||
3623 ( uniRemainingPath.Length == sizeof( WCHAR) &&
3624 uniRemainingPath.Buffer[ 0] == L'\\'))
3627 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3628 AFS_TRACE_LEVEL_VERBOSE_2,
3629 "AFSParseName (%p) Returning global root access\n",
3632 lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3634 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3635 AFS_TRACE_LEVEL_VERBOSE,
3636 "AFSParseName Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
3637 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3638 AFSGlobalRoot->DirectoryCB,
3644 FileName->Length = 0;
3645 FileName->MaximumLength = 0;
3646 FileName->Buffer = NULL;
3648 try_return( ntStatus = STATUS_SUCCESS);
3652 // Process the name again to strip off the ALL portion
3655 uniFullName = uniRemainingPath;
3657 FsRtlDissectName( uniFullName,
3662 // Check for the PIOCtl name
3665 if( RtlCompareUnicodeString( &uniComponentName,
3670 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3671 AFS_TRACE_LEVEL_VERBOSE_2,
3672 "AFSParseName (%p) Returning root PIOCtl access\n",
3675 lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
3677 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3678 AFS_TRACE_LEVEL_VERBOSE,
3679 "AFSParseName Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
3680 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
3681 AFSGlobalRoot->DirectoryCB,
3685 ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3689 *FileName = AFSPIOCtlName;
3691 try_return( ntStatus = STATUS_SUCCESS);
3694 else if( (pDirEntry = AFSGetSpecialShareNameEntry( &uniComponentName,
3695 &uniRemainingPath)) != NULL)
3698 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3699 AFS_TRACE_LEVEL_VERBOSE_2,
3700 "AFSParseName (%p) Returning root share name %wZ access\n",
3705 // Add in the full share name to pass back
3708 if( uniRemainingPath.Buffer != NULL)
3712 // This routine strips off the leading slash so add it back in
3715 uniRemainingPath.Buffer--;
3716 uniRemainingPath.Length += sizeof( WCHAR);
3717 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3720 // And the cell name
3723 uniRemainingPath.Buffer -= (uniComponentName.Length/sizeof( WCHAR));
3724 uniRemainingPath.Length += uniComponentName.Length;
3725 uniRemainingPath.MaximumLength += uniComponentName.Length;
3727 uniComponentName = uniRemainingPath;
3732 *FileName = uniComponentName;
3734 ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3736 *ParentDirectoryCB = pDirEntry;
3738 try_return( ntStatus = STATUS_SUCCESS);
3742 // Determine the 'share' we are accessing
3745 ulCRC = AFSGenerateCRC( &uniComponentName,
3748 AFSAcquireShared( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
3751 bReleaseTreeLock = TRUE;
3753 AFSLocateCaseSensitiveDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
3757 if( pDirEntry == NULL)
3760 ulCRC = AFSGenerateCRC( &uniComponentName,
3763 AFSLocateCaseInsensitiveDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
3767 if( pDirEntry == NULL)
3771 // OK, if this component is a valid short name then try
3772 // a lookup in the short name tree
3775 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3776 RtlIsNameLegalDOS8Dot3( &uniComponentName,
3781 AFSLocateShortNameDirEntry( AFSGlobalRoot->ObjectInformation.Specific.Directory.ShortNameTree,
3786 if( pDirEntry == NULL)
3790 // Check with the service whether it is a valid cell name
3793 AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
3795 bReleaseTreeLock = FALSE;
3797 ntStatus = AFSCheckCellName( AuthGroup,
3801 if( !NT_SUCCESS( ntStatus))
3805 uniRemainingPath.Length == 0 &&
3806 ntStatus == STATUS_OBJECT_PATH_NOT_FOUND)
3809 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3810 AFS_TRACE_LEVEL_VERBOSE,
3811 "AFSParseName (%p) AFSCheckCellName %wZ returned path not found; ntStatus %08X\n",
3814 STATUS_OBJECT_NAME_NOT_FOUND);
3816 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
3819 try_return( ntStatus);
3825 if( bReleaseTreeLock)
3827 AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
3832 // Be sure we are starting from the correct volume
3835 if( pDirEntry->ObjectInformation->VolumeCB != AFSGlobalRoot)
3839 // We dropped the global root in the CheckCellName routine which is the
3840 // only way we can be here
3843 pVolumeCB = pDirEntry->ObjectInformation->VolumeCB;
3846 // Init our name array
3849 pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
3852 if( pNameArray == NULL)
3855 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3856 AFS_TRACE_LEVEL_VERBOSE,
3857 "AFSParseName (%p) Failed to initialize name array\n",
3860 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3863 ntStatus = AFSInsertNextElement( pNameArray,
3864 pVolumeCB->DirectoryCB);
3869 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3870 AFS_TRACE_LEVEL_VERBOSE,
3871 "AFSParseName (%p) Failed to insert name array element\n",
3874 try_return( ntStatus);
3878 // In this case don't add back in the 'share' name since that is where we are
3879 // starting. Just put the leading slash back in
3882 if( uniRemainingPath.Buffer != NULL)
3885 uniRemainingPath.Buffer--;
3886 uniRemainingPath.Length += sizeof( WCHAR);
3887 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3889 if( uniRemainingPath.Length > sizeof( WCHAR))
3892 ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3896 // Pass back the parent being the root of the volume
3899 *ParentDirectoryCB = pVolumeCB->DirectoryCB;
3905 // Pass back a root slash
3908 uniRemainingPath = uniComponentName;
3910 uniRemainingPath.Buffer--;
3911 uniRemainingPath.Length = sizeof( WCHAR);
3912 uniRemainingPath.MaximumLength = sizeof( WCHAR);
3915 // This is a root open so pass back no parent
3922 pVolumeCB = AFSGlobalRoot;
3925 // Init our name array
3928 pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
3930 if( pNameArray == NULL)
3933 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3934 AFS_TRACE_LEVEL_VERBOSE,
3935 "AFSParseName (%p) Failed to initialize name array\n",
3938 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3942 // Add back in the 'share' portion of the name since we will parse it out on return
3945 if( uniRemainingPath.Buffer != NULL)
3949 // This routine strips off the leading slash so add it back in
3952 uniRemainingPath.Buffer--;
3953 uniRemainingPath.Length += sizeof( WCHAR);
3954 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3956 if( uniRemainingPath.Length > sizeof( WCHAR))
3959 ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
3963 // And the cell name
3966 uniRemainingPath.Buffer -= (uniComponentName.Length/sizeof( WCHAR));
3967 uniRemainingPath.Length += uniComponentName.Length;
3968 uniRemainingPath.MaximumLength += uniComponentName.Length;
3973 uniRemainingPath = uniComponentName;
3977 // And the leading slash again ...
3980 uniRemainingPath.Buffer--;
3981 uniRemainingPath.Length += sizeof( WCHAR);
3982 uniRemainingPath.MaximumLength += sizeof( WCHAR);
3985 // Pass back the parent being the volume root
3988 *ParentDirectoryCB = pVolumeCB->DirectoryCB;
3992 // Return the remaining portion as the file name
3995 *FileName = uniRemainingPath;
3997 *ParsedFileName = uniRemainingPath;
3999 *NameArray = pNameArray;
4001 *VolumeCB = pVolumeCB;
4004 // Increment our reference on the volume
4007 lCount = AFSVolumeIncrement( pVolumeCB,
4008 AFS_VOLUME_REFERENCE_PARSE_NAME);
4010 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4011 AFS_TRACE_LEVEL_VERBOSE,
4012 "AFSParseName Increment2 count on global volume %p Cnt %d\n",
4018 if( NT_SUCCESS( ntStatus))
4021 if( *ParentDirectoryCB != NULL)
4024 lCount = InterlockedIncrement( &(*ParentDirectoryCB)->DirOpenReferenceCount);
4026 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4027 AFS_TRACE_LEVEL_VERBOSE,
4028 "AFSParseName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
4029 &(*ParentDirectoryCB)->NameInformation.FileName,
4030 (*ParentDirectoryCB),
4036 if( *VolumeCB != NULL)
4038 ASSERT( (*VolumeCB)->VolumeReferenceCount > 0);
4041 if( ntStatus != STATUS_SUCCESS)
4044 if( pNameArray != NULL)
4047 AFSFreeNameArray( pNameArray);
4056 AFSCheckCellName( IN GUID *AuthGroup,
4057 IN UNICODE_STRING *CellName,
4058 OUT AFSDirectoryCB **ShareDirEntry)
4061 NTSTATUS ntStatus = STATUS_SUCCESS;
4062 UNICODE_STRING uniName;
4063 AFSDirEnumEntry *pDirEnumEntry = NULL;
4064 AFSDirHdr *pDirHdr = &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr;
4065 AFSDirectoryCB *pDirNode = NULL;
4066 UNICODE_STRING uniDirName, uniTargetName;
4067 AFSVolumeCB *pVolumeCB = NULL;
4074 // Look for some default names we will not handle
4077 RtlInitUnicodeString( &uniName,
4080 if( RtlCompareUnicodeString( &uniName,
4085 try_return( ntStatus = STATUS_NO_SUCH_FILE);
4088 RtlInitUnicodeString( &uniName,
4091 if( RtlCompareUnicodeString( &uniName,
4096 try_return( ntStatus = STATUS_NO_SUCH_FILE);
4099 RtlInitUnicodeString( &uniName,
4102 if( RtlCompareUnicodeString( &uniName,
4107 try_return( ntStatus = STATUS_NO_SUCH_FILE);
4110 RtlInitUnicodeString( &uniName,
4113 if( RtlCompareUnicodeString( &uniName,
4118 try_return( ntStatus = STATUS_NO_SUCH_FILE);
4122 // OK, ask the CM about this component name
4125 ntStatus = AFSEvaluateTargetByName( AuthGroup,
4126 &AFSGlobalRoot->ObjectInformation,
4130 if( !NT_SUCCESS( ntStatus))
4133 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4134 AFS_TRACE_LEVEL_WARNING,
4135 "AFSCheckCellName entry %wZ does not exist parent FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4137 AFSGlobalRoot->ObjectInformation.FileId.Cell,
4138 AFSGlobalRoot->ObjectInformation.FileId.Volume,
4139 AFSGlobalRoot->ObjectInformation.FileId.Vnode,
4140 AFSGlobalRoot->ObjectInformation.FileId.Unique,
4143 try_return( ntStatus);
4147 // OK, we have a dir enum entry back so add it to the root node
4150 uniDirName = *CellName;
4152 uniTargetName.Length = (USHORT)pDirEnumEntry->TargetNameLength;
4153 uniTargetName.MaximumLength = uniTargetName.Length;
4154 uniTargetName.Buffer = (WCHAR *)((char *)pDirEnumEntry + pDirEnumEntry->TargetNameOffset);
4157 // Is this entry a root volume entry?
4160 if( pDirEnumEntry->FileId.Cell != AFSGlobalRoot->ObjectInformation.FileId.Cell ||
4161 pDirEnumEntry->FileId.Volume != AFSGlobalRoot->ObjectInformation.FileId.Volume)
4165 // Build the root volume entry
4168 ntStatus = AFSBuildRootVolume( AuthGroup,
4169 &pDirEnumEntry->FileId,
4173 // On success returns with a volume reference count held
4176 if( !NT_SUCCESS( ntStatus))
4178 try_return( ntStatus);
4181 *ShareDirEntry = pVolumeCB->DirectoryCB;
4183 lCount = InterlockedIncrement( &pVolumeCB->DirectoryCB->DirOpenReferenceCount);
4185 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4186 AFS_TRACE_LEVEL_VERBOSE,
4187 "AFSCheckCellName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
4188 &pVolumeCB->DirectoryCB->NameInformation.FileName,
4189 pVolumeCB->DirectoryCB,
4193 lCount = AFSVolumeDecrement( pVolumeCB,
4194 AFS_VOLUME_REFERENCE_BUILD_ROOT);
4196 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4197 AFS_TRACE_LEVEL_VERBOSE,
4198 "AFSCheckCellName Decrement count on volume %p Cnt %d\n",
4205 lCount = InterlockedIncrement( &pDirHdr->ContentIndex);
4207 pDirNode = AFSInitDirEntry( &AFSGlobalRoot->ObjectInformation,
4213 if( pDirNode == NULL)
4216 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4220 // Init the short name if we have one
4223 if( pDirEnumEntry->ShortNameLength > 0)
4226 pDirNode->NameInformation.ShortNameLength = pDirEnumEntry->ShortNameLength;
4228 RtlCopyMemory( pDirNode->NameInformation.ShortName,
4229 pDirEnumEntry->ShortName,
4230 pDirNode->NameInformation.ShortNameLength);
4233 AFSAcquireExcl( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
4237 // Insert the node into the name tree
4240 ASSERT( ExIsResourceAcquiredExclusiveLite( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock));
4242 if( pDirHdr->CaseSensitiveTreeHead == NULL)
4245 pDirHdr->CaseSensitiveTreeHead = pDirNode;
4250 if( !NT_SUCCESS( AFSInsertCaseSensitiveDirEntry( pDirHdr->CaseSensitiveTreeHead,
4254 AFSDeleteDirEntry( &AFSGlobalRoot->ObjectInformation,
4257 AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
4259 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4263 ClearFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
4265 if( pDirHdr->CaseInsensitiveTreeHead == NULL)
4268 pDirHdr->CaseInsensitiveTreeHead = pDirNode;
4270 SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
4275 AFSInsertCaseInsensitiveDirEntry( pDirHdr->CaseInsensitiveTreeHead,
4279 if( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead == NULL)
4282 AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead = pDirNode;
4287 AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail->ListEntry.fLink = pDirNode;
4289 pDirNode->ListEntry.bLink = AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail;
4292 AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListTail = pDirNode;
4294 SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
4296 lCount = InterlockedIncrement( &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeCount);
4298 AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
4299 AFS_TRACE_LEVEL_VERBOSE,
4300 "AFSCheckCellName Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
4301 &pDirNode->NameInformation.FileName,
4303 AFSGlobalRoot->ObjectInformation.FileId.Cell,
4304 AFSGlobalRoot->ObjectInformation.FileId.Volume,
4305 AFSGlobalRoot->ObjectInformation.FileId.Vnode,
4306 AFSGlobalRoot->ObjectInformation.FileId.Unique);
4308 lCount = InterlockedIncrement( &pDirNode->DirOpenReferenceCount);
4310 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
4311 AFS_TRACE_LEVEL_VERBOSE,
4312 "AFSCheckCellName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
4313 &pDirNode->NameInformation.FileName,
4318 AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
4321 // Pass back the dir node
4324 *ShareDirEntry = pDirNode;
4329 if( pDirEnumEntry != NULL)
4332 AFSExFreePoolWithTag( pDirEnumEntry, AFS_GENERIC_MEMORY_31_TAG);
4340 AFSBuildMountPointTarget( IN GUID *AuthGroup,
4341 IN AFSDirectoryCB *DirectoryCB,
4342 OUT AFSVolumeCB **TargetVolumeCB)
4345 NTSTATUS ntStatus = STATUS_SUCCESS;
4346 AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4347 AFSDirEnumEntry *pDirEntry = NULL;
4348 ULONGLONG ullIndex = 0;
4349 AFSVolumeCB *pVolumeCB = NULL;
4350 AFSFileID stTargetFileID;
4352 BOOLEAN bReleaseVolumeLock = FALSE;
4358 // Loop on each entry, building the chain until we encounter the final target
4361 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4362 AFS_TRACE_LEVEL_VERBOSE_2,
4363 "AFSBuildMountPointTarget Building target directory for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4364 &DirectoryCB->NameInformation.FileName,
4365 DirectoryCB->ObjectInformation->FileId.Cell,
4366 DirectoryCB->ObjectInformation->FileId.Volume,
4367 DirectoryCB->ObjectInformation->FileId.Vnode,
4368 DirectoryCB->ObjectInformation->FileId.Unique);
4371 // Do we need to evaluate the node?
4374 //if( DirectoryCB->ObjectInformation->TargetFileId.Vnode == 0 &&
4375 // DirectoryCB->ObjectInformation->TargetFileId.Unique == 0)
4379 // Go evaluate the current target to get the target fid
4382 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4383 AFS_TRACE_LEVEL_VERBOSE_2,
4384 "AFSBuildMountPointTarget Evaluating target %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4385 &DirectoryCB->NameInformation.FileName,
4386 DirectoryCB->ObjectInformation->FileId.Cell,
4387 DirectoryCB->ObjectInformation->FileId.Volume,
4388 DirectoryCB->ObjectInformation->FileId.Vnode,
4389 DirectoryCB->ObjectInformation->FileId.Unique);
4391 ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
4396 if( !NT_SUCCESS( ntStatus))
4399 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4400 AFS_TRACE_LEVEL_ERROR,
4401 "AFSBuildMountPointTarget Failed to evaluate target %wZ Status %08lX\n",
4402 &DirectoryCB->NameInformation.FileName,
4404 try_return( ntStatus);
4407 if( pDirEntry->TargetFileId.Vnode == 0 &&
4408 pDirEntry->TargetFileId.Unique == 0)
4411 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4412 AFS_TRACE_LEVEL_ERROR,
4413 "AFSBuildMountPointTarget Target %wZ FID %08lX-%08lX-%08lX-%08lX service returned zero FID\n",
4414 &DirectoryCB->NameInformation.FileName,
4415 DirectoryCB->ObjectInformation->FileId.Cell,
4416 DirectoryCB->ObjectInformation->FileId.Volume,
4417 DirectoryCB->ObjectInformation->FileId.Vnode,
4418 DirectoryCB->ObjectInformation->FileId.Unique);
4420 try_return( ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED);
4423 AFSAcquireExcl( &DirectoryCB->NonPaged->Lock,
4426 ntStatus = AFSUpdateTargetName( &DirectoryCB->NameInformation.TargetName,
4427 &DirectoryCB->Flags,
4428 (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
4429 (USHORT)pDirEntry->TargetNameLength);
4431 if( !NT_SUCCESS( ntStatus))
4434 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
4436 try_return( ntStatus);
4439 AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
4441 DirectoryCB->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
4444 stTargetFileID = DirectoryCB->ObjectInformation->TargetFileId;
4447 // Try to locate this FID. First the volume then the
4451 ullIndex = AFSCreateHighIndex( &stTargetFileID);
4453 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
4454 AFS_TRACE_LEVEL_VERBOSE,
4455 "AFSBuildMountPointTarget Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
4456 &pDevExt->Specific.RDR.VolumeTreeLock,
4457 PsGetCurrentThread());
4459 AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
4462 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4463 AFS_TRACE_LEVEL_VERBOSE_2,
4464 "AFSBuildMountPointTarget Locating volume for target %I64X\n",
4467 ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
4469 (AFSBTreeEntry **)&pVolumeCB);
4472 // We can be processing a request for a target that is on a volume
4473 // we have never seen before.
4476 if( pVolumeCB == NULL)
4480 // Locking is held correctly in init routine
4483 AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4486 // Go init the root of the volume
4489 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4490 AFS_TRACE_LEVEL_VERBOSE_2,
4491 "AFSBuildMountPointTarget Initializing root for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
4492 &DirectoryCB->NameInformation.FileName,
4493 DirectoryCB->ObjectInformation->FileId.Cell,
4494 DirectoryCB->ObjectInformation->FileId.Volume,
4495 DirectoryCB->ObjectInformation->FileId.Vnode,
4496 DirectoryCB->ObjectInformation->FileId.Unique);
4498 ntStatus = AFSInitVolume( AuthGroup,
4500 AFS_VOLUME_REFERENCE_MOUNTPT,
4503 if( !NT_SUCCESS( ntStatus))
4506 try_return( ntStatus);
4510 // pVolumeCB->VolumeLock held exclusive and
4511 // pVolumeCB->VolumeReferenceCount has been incremented
4512 // pVolumeCB->RootFcb == NULL
4515 bReleaseVolumeLock = TRUE;
4521 // AFSInitVolume returns with a VolumeReferenceCount
4522 // obtain one to match
4525 lCount = AFSVolumeIncrement( pVolumeCB,
4526 AFS_VOLUME_REFERENCE_MOUNTPT);
4528 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4529 AFS_TRACE_LEVEL_VERBOSE,
4530 "AFSBuildMountPointTarget Increment count on volume %p Cnt %d\n",
4534 AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4537 if( pVolumeCB->RootFcb == NULL)
4540 if ( bReleaseVolumeLock == FALSE)
4543 AFSAcquireExcl( pVolumeCB->VolumeLock,
4546 bReleaseVolumeLock = TRUE;
4550 // Initialize the root fcb for this volume
4553 ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
4556 if( !NT_SUCCESS( ntStatus))
4559 lCount = AFSVolumeDecrement( pVolumeCB,
4560 AFS_VOLUME_REFERENCE_MOUNTPT);
4562 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4563 AFS_TRACE_LEVEL_VERBOSE,
4564 "AFSBuildMountPoint Decrement count on volume %p Cnt %d\n",
4568 AFSReleaseResource( pVolumeCB->VolumeLock);
4570 try_return( ntStatus);
4574 // Drop the lock acquired above
4577 AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
4580 if ( bReleaseVolumeLock == TRUE)
4583 AFSReleaseResource( pVolumeCB->VolumeLock);
4586 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4587 AFS_TRACE_LEVEL_VERBOSE_2,
4588 "AFSBuildMountPointTarget Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
4589 &pVolumeCB->DirectoryCB->NameInformation.FileName,
4590 pVolumeCB->ObjectInformation.FileId.Cell,
4591 pVolumeCB->ObjectInformation.FileId.Volume,
4592 pVolumeCB->ObjectInformation.FileId.Vnode,
4593 pVolumeCB->ObjectInformation.FileId.Unique);
4595 *TargetVolumeCB = pVolumeCB;
4602 AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
4610 AFSBuildRootVolume( IN GUID *AuthGroup,
4611 IN AFSFileID *FileId,
4612 OUT AFSVolumeCB **TargetVolumeCB)
4615 NTSTATUS ntStatus = STATUS_SUCCESS;
4616 AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
4617 ULONGLONG ullIndex = 0;
4618 AFSVolumeCB *pVolumeCB = NULL;
4620 BOOLEAN bReleaseVolumeLock = FALSE;
4625 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4626 AFS_TRACE_LEVEL_VERBOSE_2,
4627 "AFSBuildRootVolume Building target volume for FID %08lX-%08lX-%08lX-%08lX\n",
4633 ullIndex = AFSCreateHighIndex( FileId);
4635 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
4636 AFS_TRACE_LEVEL_VERBOSE,
4637 "AFSBuildRootVolume Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
4638 &pDevExt->Specific.RDR.VolumeTreeLock,
4639 PsGetCurrentThread());
4641 AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
4644 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4645 AFS_TRACE_LEVEL_VERBOSE_2,
4646 "AFSBuildRootVolume Locating volume for target %I64X\n",
4649 ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
4651 (AFSBTreeEntry **)&pVolumeCB);
4654 // We can be processing a request for a target that is on a volume
4655 // we have never seen before.
4658 if( pVolumeCB == NULL)
4662 // Locking is held correctly in init routine
4665 AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4668 // Go init the root of the volume
4671 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4672 AFS_TRACE_LEVEL_VERBOSE_2,
4673 "AFSBuildRootVolume Initializing root for FID %08lX-%08lX-%08lX-%08lX\n",
4679 ntStatus = AFSInitVolume( AuthGroup,
4681 AFS_VOLUME_REFERENCE_BUILD_ROOT,
4684 if( !NT_SUCCESS( ntStatus))
4687 try_return( ntStatus);
4691 // pVolumeCB->VolumeLock is held exclusive
4692 // pVolumeCB->VolumeReferenceCount has been incremented
4693 // pVolumeCB->RootFcb == NULL
4696 bReleaseVolumeLock = TRUE;
4702 // AFSInitVolume returns with a VolumeReferenceCount
4703 // obtain one to match
4706 lCount = AFSVolumeIncrement( pVolumeCB,
4707 AFS_VOLUME_REFERENCE_BUILD_ROOT);
4709 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4710 AFS_TRACE_LEVEL_VERBOSE,
4711 "AFSBuildRootVolume Increment count on volume %p Cnt %d\n",
4715 AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
4719 if( pVolumeCB->RootFcb == NULL)
4722 if ( bReleaseVolumeLock == FALSE)
4725 AFSAcquireExcl( pVolumeCB->VolumeLock,
4728 bReleaseVolumeLock = TRUE;
4732 // Initialize the root fcb for this volume
4735 ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
4738 if( !NT_SUCCESS( ntStatus))
4741 lCount = AFSVolumeDecrement( pVolumeCB,
4742 AFS_VOLUME_REFERENCE_BUILD_ROOT);
4744 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
4745 AFS_TRACE_LEVEL_VERBOSE,
4746 "AFSBuildRootVolume Decrement count on volume %p Cnt %d\n",
4750 AFSReleaseResource( pVolumeCB->VolumeLock);
4752 try_return( ntStatus);
4756 // Drop the lock acquired above
4759 AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
4762 if ( bReleaseVolumeLock == TRUE)
4765 AFSReleaseResource( pVolumeCB->VolumeLock);
4768 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4769 AFS_TRACE_LEVEL_VERBOSE_2,
4770 "AFSBuildRootVolume Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
4771 &pVolumeCB->DirectoryCB->NameInformation.FileName,
4772 pVolumeCB->ObjectInformation.FileId.Cell,
4773 pVolumeCB->ObjectInformation.FileId.Volume,
4774 pVolumeCB->ObjectInformation.FileId.Vnode,
4775 pVolumeCB->ObjectInformation.FileId.Unique);
4777 *TargetVolumeCB = pVolumeCB;
4788 AFSProcessDFSLink( IN AFSDirectoryCB *DirEntry,
4789 IN PFILE_OBJECT FileObject,
4790 IN UNICODE_STRING *RemainingPath,
4794 NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
4795 UNICODE_STRING uniReparseName;
4796 UNICODE_STRING uniMUPDeviceName;
4797 UNICODE_STRING uniIOMgrDeviceName;
4798 AFSDirEnumEntry *pDirEntry = NULL;
4804 // Build up the name to reparse
4807 RtlInitUnicodeString( &uniMUPDeviceName,
4810 RtlInitUnicodeString( &uniIOMgrDeviceName,
4813 uniReparseName.Length = 0;
4814 uniReparseName.Buffer = NULL;
4817 // Be sure we have a target name
4820 if( DirEntry->NameInformation.TargetName.Length == 0)
4823 ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
4828 if( !NT_SUCCESS( ntStatus) ||
4829 pDirEntry->TargetNameLength == 0)
4832 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4833 AFS_TRACE_LEVEL_ERROR,
4834 "AFSProcessDFSLink EvaluateTargetByID failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4835 &DirEntry->NameInformation.FileName,
4836 DirEntry->ObjectInformation->FileId.Cell,
4837 DirEntry->ObjectInformation->FileId.Volume,
4838 DirEntry->ObjectInformation->FileId.Vnode,
4839 DirEntry->ObjectInformation->FileId.Unique,
4842 if( NT_SUCCESS( ntStatus))
4845 ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
4848 try_return( ntStatus);
4852 // Update the target name
4855 AFSAcquireExcl( &DirEntry->NonPaged->Lock,
4858 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
4860 (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset),
4861 (USHORT)pDirEntry->TargetNameLength);
4863 if( !NT_SUCCESS( ntStatus))
4866 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4867 AFS_TRACE_LEVEL_ERROR,
4868 "AFSProcessDFSLink UpdateTargetName failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4869 &DirEntry->NameInformation.FileName,
4870 DirEntry->ObjectInformation->FileId.Cell,
4871 DirEntry->ObjectInformation->FileId.Volume,
4872 DirEntry->ObjectInformation->FileId.Vnode,
4873 DirEntry->ObjectInformation->FileId.Unique,
4876 AFSReleaseResource( &DirEntry->NonPaged->Lock);
4878 try_return( ntStatus);
4881 AFSConvertToShared( &DirEntry->NonPaged->Lock);
4885 AFSAcquireShared( &DirEntry->NonPaged->Lock,
4889 uniReparseName.MaximumLength = uniMUPDeviceName.Length +
4891 DirEntry->NameInformation.TargetName.Length +
4894 if( RemainingPath != NULL &&
4895 RemainingPath->Length > 0)
4898 uniReparseName.MaximumLength += RemainingPath->Length;
4902 // Allocate the reparse buffer
4905 uniReparseName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
4906 uniReparseName.MaximumLength,
4907 AFS_REPARSE_NAME_TAG);
4909 if( uniReparseName.Buffer == NULL)
4912 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
4913 AFS_TRACE_LEVEL_ERROR,
4914 "AFSProcessDFSLink uniReparseName.Buffer == NULL Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
4915 &DirEntry->NameInformation.FileName,
4916 DirEntry->ObjectInformation->FileId.Cell,
4917 DirEntry->ObjectInformation->FileId.Volume,
4918 DirEntry->ObjectInformation->FileId.Vnode,
4919 DirEntry->ObjectInformation->FileId.Unique,
4920 STATUS_INSUFFICIENT_RESOURCES);
4922 AFSReleaseResource( &DirEntry->NonPaged->Lock);
4924 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4928 // Start building the name
4931 if ( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\' &&
4932 DirEntry->NameInformation.TargetName.Buffer[ 1] == L':')
4935 RtlCopyMemory( uniReparseName.Buffer,
4936 uniIOMgrDeviceName.Buffer,
4937 uniIOMgrDeviceName.Length);
4939 uniReparseName.Length = uniIOMgrDeviceName.Length;
4944 RtlCopyMemory( uniReparseName.Buffer,
4945 uniMUPDeviceName.Buffer,
4946 uniMUPDeviceName.Length);
4948 uniReparseName.Length = uniMUPDeviceName.Length;
4950 if( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\')
4953 uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
4955 uniReparseName.Length += sizeof( WCHAR);
4959 RtlCopyMemory( &uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)],
4960 DirEntry->NameInformation.TargetName.Buffer,
4961 DirEntry->NameInformation.TargetName.Length);
4963 uniReparseName.Length += DirEntry->NameInformation.TargetName.Length;
4965 AFSReleaseResource( &DirEntry->NonPaged->Lock);
4967 if( RemainingPath != NULL &&
4968 RemainingPath->Length > 0)
4971 if( uniReparseName.Buffer[ (uniReparseName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
4972 RemainingPath->Buffer[ 0] != L'\\')
4975 uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
4977 uniReparseName.Length += sizeof( WCHAR);
4980 RtlCopyMemory( &uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)],
4981 RemainingPath->Buffer,
4982 RemainingPath->Length);
4984 uniReparseName.Length += RemainingPath->Length;
4988 // Update the name in the file object
4991 if( FileObject->FileName.Buffer != NULL)
4994 AFSExFreePoolWithTag( FileObject->FileName.Buffer, 0);
4997 FileObject->FileName = uniReparseName;
4999 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
5000 AFS_TRACE_LEVEL_VERBOSE,
5001 "AFSProcessDFSLink Reparsing access to Fcb %wZ FID %08lX-%08lX-%08lX-%08lX to %wZ\n",
5002 &DirEntry->NameInformation.FileName,
5003 DirEntry->ObjectInformation->FileId.Cell,
5004 DirEntry->ObjectInformation->FileId.Volume,
5005 DirEntry->ObjectInformation->FileId.Vnode,
5006 DirEntry->ObjectInformation->FileId.Unique,
5010 // Return status reparse ...
5013 ntStatus = STATUS_REPARSE;
5020 AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);