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