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