2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * - Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
14 * this list of conditions and the following disclaimer in the
16 * and/or other materials provided with the distribution.
17 * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
18 * nor the names of their contributors may be used to endorse or promote
19 * products derived from this software without specific prior written
20 * permission from Kernel Drivers, LLC and Your File System, Inc.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 // File: AFSCreate.cpp
39 #include "AFSCommon.h"
42 // Function: AFSCreate
46 // This function is the dispatch handler for the IRP_MJ_CREATE requests. It makes the determination to
47 // which interface this request is destined.
51 // A status is returned for the function. The Irp completion processing is handled in the specific
56 AFSCreate( IN PDEVICE_OBJECT LibDeviceObject,
60 NTSTATUS ntStatus = STATUS_SUCCESS;
61 IO_STACK_LOCATION *pIrpSp;
62 FILE_OBJECT *pFileObject = NULL;
67 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
68 pFileObject = pIrpSp->FileObject;
70 if( pFileObject == NULL ||
71 pFileObject->FileName.Buffer == NULL)
74 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
75 AFS_TRACE_LEVEL_VERBOSE,
76 "AFSCreate (%08lX) Processing control device open request\n",
79 ntStatus = AFSControlDeviceCreate( Irp);
81 try_return( ntStatus);
84 if( AFSRDRDeviceObject == NULL)
87 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
88 AFS_TRACE_LEVEL_VERBOSE,
89 "AFSCreate (%08lX) Invalid request to open before library is initialized\n",
92 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
95 ntStatus = AFSCommonCreate( AFSRDRDeviceObject,
102 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
107 "EXCEPTION - AFSCreate\n");
109 ntStatus = STATUS_ACCESS_DENIED;
111 AFSDumpTraceFilesFnc();
115 // Complete the request
118 AFSCompleteRequest( Irp,
125 AFSCommonCreate( IN PDEVICE_OBJECT DeviceObject,
129 NTSTATUS ntStatus = STATUS_SUCCESS;
130 UNICODE_STRING uniFileName;
131 ULONG ulCreateDisposition = 0;
133 BOOLEAN bNoIntermediateBuffering = FALSE;
134 FILE_OBJECT *pFileObject = NULL;
135 IO_STACK_LOCATION *pIrpSp;
138 AFSDeviceExt *pDeviceExt = NULL;
139 BOOLEAN bOpenTargetDirectory = FALSE, bReleaseVolume = FALSE;
140 PACCESS_MASK pDesiredAccess = NULL;
141 UNICODE_STRING uniComponentName, uniPathName, uniRootFileName, uniParsedFileName;
142 UNICODE_STRING uniSubstitutedPathName;
143 UNICODE_STRING uniRelativeName;
144 AFSNameArrayHdr *pNameArray = NULL;
145 AFSVolumeCB *pVolumeCB = NULL;
146 AFSDirectoryCB *pParentDirectoryCB = NULL, *pDirectoryCB = NULL;
147 ULONG ulParseFlags = 0;
149 ULONG ulNameProcessingFlags = 0;
150 BOOLEAN bOpenedReparsePoint = FALSE;
156 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
157 pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
158 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
159 ulOptions = pIrpSp->Parameters.Create.Options;
160 bNoIntermediateBuffering = BooleanFlagOn( ulOptions, FILE_NO_INTERMEDIATE_BUFFERING);
161 bOpenTargetDirectory = BooleanFlagOn( pIrpSp->Flags, SL_OPEN_TARGET_DIRECTORY);
162 pFileObject = pIrpSp->FileObject;
163 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
165 uniFileName.Length = uniFileName.MaximumLength = 0;
166 uniFileName.Buffer = NULL;
168 uniRootFileName.Length = uniRootFileName.MaximumLength = 0;
169 uniRootFileName.Buffer = NULL;
171 uniParsedFileName.Length = uniParsedFileName.MaximumLength = 0;
172 uniParsedFileName.Buffer = NULL;
174 uniSubstitutedPathName.Buffer = NULL;
175 uniSubstitutedPathName.Length = 0;
177 uniRelativeName.Buffer = NULL;
178 uniRelativeName.Length = 0;
180 if( AFSGlobalRoot == NULL)
182 try_return( ntStatus = STATUS_DEVICE_NOT_READY);
185 RtlZeroMemory( &stAuthGroup,
188 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
189 (ULONGLONG)PsGetCurrentThreadId(),
193 // If we are in shutdown mode then fail the request
196 if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
199 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
200 AFS_TRACE_LEVEL_WARNING,
201 "AFSCommonCreate (%08lX) Open request after shutdown\n",
204 try_return( ntStatus = STATUS_TOO_LATE);
207 if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
210 ntStatus = AFSEnumerateGlobalRoot( &stAuthGroup);
212 if( !NT_SUCCESS( ntStatus))
215 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
216 AFS_TRACE_LEVEL_ERROR,
217 "AFSCommonCreate Failed to enumerate global root Status %08lX\n",
220 try_return( ntStatus);
225 // Go and parse the name for processing.
226 // If ulParseFlags is returned with AFS_PARSE_FLAG_FREE_FILE_BUFFER set,
227 // then we are responsible for releasing the uniRootFileName.Buffer.
230 ntStatus = AFSParseName( Irp,
240 if( !NT_SUCCESS( ntStatus))
243 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
244 uniFileName.Length > 0 ? AFS_TRACE_LEVEL_ERROR : AFS_TRACE_LEVEL_VERBOSE,
245 "AFSCommonCreate (%08lX) Failed to parse name \"%wZ\" Status %08lX\n",
250 try_return( ntStatus);
254 // Check for STATUS_REPARSE
257 if( ntStatus == STATUS_REPARSE)
261 // Update the information and return
264 Irp->IoStatus.Information = IO_REPARSE;
266 try_return( ntStatus);
270 // If the returned volume cb is NULL then we are dealing with the \\Server\GlobalRoot
274 if( pVolumeCB == NULL)
278 // Remove any leading or trailing slashes
281 if( uniFileName.Length >= sizeof( WCHAR) &&
282 uniFileName.Buffer[ (uniFileName.Length/sizeof( WCHAR)) - 1] == L'\\')
285 uniFileName.Length -= sizeof( WCHAR);
288 if( uniFileName.Length >= sizeof( WCHAR) &&
289 uniFileName.Buffer[ 0] == L'\\')
292 uniFileName.Buffer = &uniFileName.Buffer[ 1];
294 uniFileName.Length -= sizeof( WCHAR);
298 // If there is a remaining portion returned for this request then
299 // check if it is for the PIOCtl interface
302 if( uniFileName.Length > 0)
306 // We don't accept any other opens off of the AFS Root
309 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
312 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
315 if( RtlCompareUnicodeString( &AFSPIOCtlName,
320 ntStatus = AFSOpenIOCtlFcb( Irp,
322 AFSGlobalRoot->DirectoryCB,
326 if( !NT_SUCCESS( ntStatus))
329 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
330 AFS_TRACE_LEVEL_ERROR,
331 "AFSCommonCreate Failed to open root IOCtl Fcb Status %08lX\n",
335 else if( pParentDirectoryCB != NULL &&
336 pParentDirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SPECIAL_SHARE_NAME)
339 ntStatus = AFSOpenSpecialShareFcb( Irp,
345 if( !NT_SUCCESS( ntStatus))
348 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
349 AFS_TRACE_LEVEL_ERROR,
350 "AFSCommonCreate Failed to open special share Fcb Status %08lX\n",
355 try_return( ntStatus);
358 ntStatus = AFSOpenAFSRoot( Irp,
362 if( !NT_SUCCESS( ntStatus))
365 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
366 AFS_TRACE_LEVEL_ERROR,
367 "AFSCommonCreate Failed to open root Status %08lX\n",
370 lCount = InterlockedDecrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
372 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
373 AFS_TRACE_LEVEL_VERBOSE,
374 "AFSCommonCreate Decrement1 count on &wZ DE %p Ccb %p Cnt %d\n",
375 &AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
376 AFSGlobalRoot->DirectoryCB,
381 try_return( ntStatus);
385 // We have a reference on the root volume
388 bReleaseVolume = TRUE;
391 // Attempt to locate the node in the name tree if this is not a target
392 // open and the target is not the root
395 uniComponentName.Length = 0;
396 uniComponentName.Buffer = NULL;
398 if( uniFileName.Length > sizeof( WCHAR) ||
399 uniFileName.Buffer[ 0] != L'\\')
402 if( !AFSValidNameFormat( &uniFileName))
405 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
407 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
408 AFS_TRACE_LEVEL_VERBOSE,
409 "AFSCommonCreate (%08lX) Invalid name %wZ Status %08lX\n",
414 try_return( ntStatus);
418 // Opening a reparse point directly?
421 ulNameProcessingFlags = AFS_LOCATE_FLAGS_SUBSTITUTE_NAME;
423 if( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT))
425 ulNameProcessingFlags |= (AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL |
426 AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL |
427 AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL);
430 uniSubstitutedPathName = uniRootFileName;
432 ntStatus = AFSLocateNameEntry( &stAuthGroup,
437 ulNameProcessingFlags,
443 if( !NT_SUCCESS( ntStatus) &&
444 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
447 if ( uniSubstitutedPathName.Buffer == uniRootFileName.Buffer)
449 uniSubstitutedPathName.Buffer = NULL;
453 // The routine above released the root while walking the
457 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
458 AFS_TRACE_LEVEL_VERBOSE,
459 "AFSCommonCreate (%08lX) Failed to locate name entry for %wZ Status %08lX\n",
465 // We released any root volume locks in the above on failure
468 bReleaseVolume = FALSE;
470 try_return( ntStatus);
474 // Check for STATUS_REPARSE
477 if( ntStatus == STATUS_REPARSE)
480 uniSubstitutedPathName.Buffer = NULL;
483 // Update the information and return
486 Irp->IoStatus.Information = IO_REPARSE;
489 // We released the volume lock above
492 bReleaseVolume = FALSE;
494 try_return( ntStatus);
498 // If we re-allocated the name, then update our substitute name
501 if( uniSubstitutedPathName.Buffer != uniRootFileName.Buffer)
504 uniSubstitutedPathName = uniRootFileName;
509 uniSubstitutedPathName.Buffer = NULL;
513 // Check for a symlink access
516 if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND &&
517 pParentDirectoryCB != NULL)
520 UNICODE_STRING uniFinalComponent;
522 uniFinalComponent.Length = 0;
523 uniFinalComponent.MaximumLength = 0;
524 uniFinalComponent.Buffer = NULL;
526 AFSRetrieveFinalComponent( &uniFileName,
529 ntStatus = AFSCheckSymlinkAccess( pParentDirectoryCB,
532 if( !NT_SUCCESS( ntStatus) &&
533 ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
536 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
537 AFS_TRACE_LEVEL_VERBOSE,
538 "AFSCommonCreate (%08lX) Failing access to symlink %wZ Status %08lX\n",
543 try_return( ntStatus);
549 // If we have no parent then this is a root open, be sure there is a directory entry
553 else if( pParentDirectoryCB == NULL &&
554 pDirectoryCB == NULL)
557 pDirectoryCB = pVolumeCB->DirectoryCB;
560 if( bOpenTargetDirectory)
564 // If we have a directory cb for the entry then dereference it and reference the parent
567 if( pDirectoryCB != NULL)
571 // Perform in this order to prevent thrashing
574 lCount = InterlockedIncrement( &pParentDirectoryCB->OpenReferenceCount);
576 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
577 AFS_TRACE_LEVEL_VERBOSE,
578 "AFSCommonCreate Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
579 &pParentDirectoryCB->NameInformation.FileName,
585 // Do NOT decrement the reference count on the pDirectoryCB yet.
586 // The BackupEntry below might drop the count to zero leaving
587 // the entry subject to being deleted and we need some of the
588 // contents during later processing
591 AFSBackupEntry( pNameArray);
595 // OK, open the target directory
598 if( uniComponentName.Length == 0)
600 AFSRetrieveFinalComponent( &uniFileName,
604 ntStatus = AFSOpenTargetDirectory( Irp,
611 if( pDirectoryCB != NULL)
614 // It is now safe to drop the Reference Count
616 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
618 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
619 AFS_TRACE_LEVEL_VERBOSE,
620 "AFSCommonCreate Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
621 &pDirectoryCB->NameInformation.FileName,
627 if( !NT_SUCCESS( ntStatus))
630 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
631 AFS_TRACE_LEVEL_ERROR,
632 "AFSCommonCreate Failed to open target directory %wZ Status %08lX\n",
633 &pParentDirectoryCB->NameInformation.FileName,
637 // Decrement the reference on the parent
640 lCount = InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
642 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
643 AFS_TRACE_LEVEL_VERBOSE,
644 "AFSCommonCreate Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
645 &pParentDirectoryCB->NameInformation.FileName,
651 try_return( ntStatus);
654 if ( BooleanFlagOn( ulOptions, FILE_OPEN_REPARSE_POINT))
657 if( pDirectoryCB == NULL ||
658 !BooleanFlagOn( pDirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
660 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
661 AFS_TRACE_LEVEL_VERBOSE,
662 "AFSCommonCreate (%08lX) Reparse open request but attribute not set for %wZ DirCB %p Type %08lX\n",
666 pDirectoryCB ? pDirectoryCB->ObjectInformation->FileType : 0);
670 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
671 AFS_TRACE_LEVEL_VERBOSE,
672 "AFSCommonCreate (%08lX) Opening as reparse point %wZ Type %08lX\n",
675 pDirectoryCB->ObjectInformation->FileType);
677 bOpenedReparsePoint = TRUE;
682 // Based on the options passed in, process the file accordingly.
685 if( ulCreateDisposition == FILE_CREATE ||
686 ( ( ulCreateDisposition == FILE_OPEN_IF ||
687 ulCreateDisposition == FILE_OVERWRITE_IF) &&
688 pDirectoryCB == NULL))
691 if( uniComponentName.Length == 0 ||
692 pDirectoryCB != NULL)
696 // We traversed the entire path so we found each entry,
697 // fail with collision
700 if( pDirectoryCB != NULL)
703 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
704 AFS_TRACE_LEVEL_VERBOSE,
705 "AFSCommonCreate Object name collision on create of %wZ Status %08lX\n",
706 &pDirectoryCB->NameInformation.FileName,
709 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
711 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
712 AFS_TRACE_LEVEL_VERBOSE,
713 "AFSCommonCreate Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
714 &pDirectoryCB->NameInformation.FileName,
722 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
723 AFS_TRACE_LEVEL_VERBOSE,
724 "AFSCommonCreate Object name collision on create Status %08lX\n",
727 InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
729 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
730 AFS_TRACE_LEVEL_VERBOSE,
731 "AFSCommonCreate Decrement5 count on %wZ DE %p Ccb %p Cnt %d\n",
732 &pParentDirectoryCB->NameInformation.FileName,
735 pParentDirectoryCB->OpenReferenceCount);
738 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
742 // OK, go and create the node
745 ntStatus = AFSProcessCreate( Irp,
755 if( !NT_SUCCESS( ntStatus))
758 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
759 AFS_TRACE_LEVEL_ERROR,
760 "AFSCommonCreate Failed to create of %wZ in directory %wZ Status %08lX\n",
762 &pParentDirectoryCB->NameInformation.FileName,
767 // Dereference the parent entry
770 lCount = InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
772 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
773 AFS_TRACE_LEVEL_VERBOSE,
774 "AFSCreate Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
775 &pParentDirectoryCB->NameInformation.FileName,
780 try_return( ntStatus);
784 // We should not have an extra component except for PIOCtl opens
787 if( uniComponentName.Length > 0)
791 // If this is an open on "_._AFS_IOCTL_._" then perform handling on it accordingly
794 if( RtlCompareUnicodeString( &AFSPIOCtlName,
799 ntStatus = AFSOpenIOCtlFcb( Irp,
805 if( !NT_SUCCESS( ntStatus))
808 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
809 AFS_TRACE_LEVEL_ERROR,
810 "AFSCommonCreate Failed to IOCtl open on %wZ Status %08lX\n",
818 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
819 AFS_TRACE_LEVEL_VERBOSE,
820 "AFSCommonCreate (%08lX) File %wZ name not found\n",
824 ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
827 if( !NT_SUCCESS( ntStatus))
831 // Dereference the parent entry
834 if( pDirectoryCB != NULL)
837 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
839 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
840 AFS_TRACE_LEVEL_VERBOSE,
841 "AFSCommonCreate Decrement7a count on %wZ DE %p Ccb %p Cnt %d\n",
842 &pDirectoryCB->NameInformation.FileName,
850 lCount = InterlockedDecrement( &pParentDirectoryCB->OpenReferenceCount);
852 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
853 AFS_TRACE_LEVEL_VERBOSE,
854 "AFSCommonCreate Decrement7b count on %wZ DE %p Ccb %p Cnt %d\n",
855 &pParentDirectoryCB->NameInformation.FileName,
862 try_return( ntStatus);
866 // For root opens the parent will be NULL
869 if( pParentDirectoryCB == NULL)
873 // Check for the delete on close flag for the root
876 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE ))
879 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
880 AFS_TRACE_LEVEL_ERROR,
881 "AFSCommonCreate (%08lX) Attempt to open root as delete on close\n",
884 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
886 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
887 AFS_TRACE_LEVEL_VERBOSE,
888 "AFSCommonCreate Decrement8 count on %wZ DE %p Ccb %p Cnt %d\n",
889 &pDirectoryCB->NameInformation.FileName,
894 try_return( ntStatus = STATUS_CANNOT_DELETE);
898 // If this is the target directory, then bail
901 if( bOpenTargetDirectory)
904 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
905 AFS_TRACE_LEVEL_ERROR,
906 "AFSCommonCreate (%08lX) Attempt to open root as target directory\n",
909 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
911 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
912 AFS_TRACE_LEVEL_VERBOSE,
913 "AFSCommonCreate Decrement9 count on %wZ DE %p Ccb %p Cnt %d\n",
914 &pDirectoryCB->NameInformation.FileName,
919 try_return( ntStatus = STATUS_INVALID_PARAMETER);
923 // Go and open the root of the volume
926 ntStatus = AFSOpenRoot( Irp,
932 if( !NT_SUCCESS( ntStatus))
935 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
936 AFS_TRACE_LEVEL_ERROR,
937 "AFSCommonCreate Failed to open volume root %08lX-%08lX Status %08lX\n",
938 pVolumeCB->ObjectInformation.FileId.Cell,
939 pVolumeCB->ObjectInformation.FileId.Volume,
942 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
944 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
945 AFS_TRACE_LEVEL_VERBOSE,
946 "AFSCommonCreate Decrement10 count on %wZ DE %p Ccb %p Cnt %d\n",
947 &pDirectoryCB->NameInformation.FileName,
953 try_return( ntStatus);
957 // At this point if we have no pDirectoryCB it was not found.
960 if( pDirectoryCB == NULL)
963 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
964 AFS_TRACE_LEVEL_ERROR,
965 "AFSCommonCreate Failing access to %wZ\n",
968 try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
971 if( ulCreateDisposition == FILE_OVERWRITE ||
972 ulCreateDisposition == FILE_SUPERSEDE ||
973 ulCreateDisposition == FILE_OVERWRITE_IF)
977 // Go process a file for overwrite or supersede.
980 ntStatus = AFSProcessOverwriteSupersede( DeviceObject,
989 if( !NT_SUCCESS( ntStatus))
992 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
993 AFS_TRACE_LEVEL_ERROR,
994 "AFSCommonCreate Failed overwrite/supersede on %wZ Status %08lX\n",
995 &pDirectoryCB->NameInformation.FileName,
998 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
1000 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1001 AFS_TRACE_LEVEL_VERBOSE,
1002 "AFSCommonCreate Decrement11 count on %wZ DE %p Ccb %p Cnt %d\n",
1003 &pDirectoryCB->NameInformation.FileName,
1009 try_return( ntStatus);
1013 // Trying to open the file
1016 ntStatus = AFSProcessOpen( Irp,
1024 if( !NT_SUCCESS( ntStatus))
1027 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1028 AFS_TRACE_LEVEL_ERROR,
1029 "AFSCommonCreate Failed open on %wZ Status %08lX\n",
1030 &pDirectoryCB->NameInformation.FileName,
1033 lCount = InterlockedDecrement( &pDirectoryCB->OpenReferenceCount);
1035 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1036 AFS_TRACE_LEVEL_VERBOSE,
1037 "AFSCommonCreate Decrement12 count on %wZ DE %p Ccb %p Cnt %d\n",
1038 &pDirectoryCB->NameInformation.FileName,
1046 if( NT_SUCCESS( ntStatus) &&
1047 ntStatus != STATUS_REPARSE)
1053 RtlCopyMemory( &pCcb->AuthGroup,
1058 // If we have a substitute name, then use it
1061 if( uniSubstitutedPathName.Buffer != NULL)
1064 pCcb->FullFileName = uniSubstitutedPathName;
1066 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1068 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1073 pCcb->FullFileName = uniRootFileName;
1075 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1078 SetFlag( pCcb->Flags, CCB_FLAG_FREE_FULL_PATHNAME);
1080 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1084 if( bOpenedReparsePoint)
1086 SetFlag( pCcb->Flags, CCB_FLAG_MASK_OPENED_REPARSE_POINT);
1089 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
1090 AFS_TRACE_LEVEL_VERBOSE,
1091 "AFSCommonCreate Count on %wZ DE %p Ccb %p Cnt %d\n",
1092 &pCcb->DirectoryCB->NameInformation.FileName,
1095 pCcb->DirectoryCB->OpenReferenceCount);
1097 ASSERT( pCcb->DirectoryCB->OpenReferenceCount > 0);
1099 pCcb->CurrentDirIndex = 0;
1101 if( !BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS))
1104 SetFlag( pCcb->Flags, CCB_FLAG_RETURN_RELATIVE_ENTRIES);
1108 // Save off the name array for this instance
1111 pCcb->NameArray = pNameArray;
1117 // If we make it here then init the FO for the request.
1120 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1121 AFS_TRACE_LEVEL_VERBOSE_2,
1122 "AFSCommonCreate (%08lX) FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1128 pFileObject->FsContext = (void *)pFcb;
1130 pFileObject->FsContext2 = (void *)pCcb;
1135 ASSERT( pFcb->OpenHandleCount > 0);
1137 ClearFlag( pFcb->Flags, AFS_FCB_FILE_CLOSED);
1140 // For files perform additional processing
1143 switch( pFcb->Header.NodeTypeCode)
1150 pFileObject->SectionObjectPointer = &pFcb->NPFcb->SectionObjectPointers;
1155 // If the user did not request nobuffering then mark the FO as cacheable
1158 if( bNoIntermediateBuffering)
1161 pFileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
1166 pFileObject->Flags |= FO_CACHE_SUPPORTED;
1170 // If the file was opened for execution then we need to set the bit in the FO
1173 if( BooleanFlagOn( *pDesiredAccess,
1177 SetFlag( pFileObject->Flags, FO_FILE_FAST_IO_READ);
1181 // Update the last access time
1184 KeQuerySystemTime( &pFcb->ObjectInformation->LastAccessTime);
1195 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1196 AFS_TRACE_LEVEL_ERROR,
1197 "AFSCommonCreate (%08lX) Returning with NULL Fcb FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1206 if( NT_SUCCESS( ntStatus) &&
1207 ntStatus == STATUS_REPARSE)
1210 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1211 AFS_TRACE_LEVEL_ERROR,
1212 "AFSCommonCreate (%08lX) STATUS_REPARSE FileObject %08lX FsContext %08lX FsContext2 %08lX\n",
1220 // Free up the sub name if we have one
1223 if( uniSubstitutedPathName.Buffer != NULL)
1226 AFSExFreePool( uniSubstitutedPathName.Buffer);
1228 ClearFlag( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
1233 // Free up the name array ...
1236 if( pNameArray != NULL)
1239 AFSFreeNameArray( pNameArray);
1242 if( BooleanFlagOn( ulParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER))
1245 AFSExFreePool( uniRootFileName.Buffer);
1251 lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1253 AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1254 AFS_TRACE_LEVEL_VERBOSE,
1255 "AFSCommonCreate Decrement count on Volume %08lX Cnt %d\n",
1261 // Setup the Irp for completion, the Information has been set previously
1264 Irp->IoStatus.Status = ntStatus;
1271 AFSOpenAFSRoot( IN PIRP Irp,
1276 NTSTATUS ntStatus = STATUS_SUCCESS;
1283 // Initialize the Ccb for the file.
1286 ntStatus = AFSInitCcb( Ccb);
1288 if( !NT_SUCCESS( ntStatus))
1291 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1292 AFS_TRACE_LEVEL_ERROR,
1293 "AFSOpenAFSRoot (%08lX) Failed to allocate Ccb\n",
1296 try_return( ntStatus);
1303 (*Ccb)->DirectoryCB = AFSGlobalRoot->DirectoryCB;
1306 // Increment the open count on this Fcb
1309 lCount = InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenReferenceCount);
1311 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1312 AFS_TRACE_LEVEL_VERBOSE,
1313 "AFSOpenAFSRoot Increment count on Fcb %08lX Cnt %d\n",
1314 AFSGlobalRoot->RootFcb,
1317 lCount = InterlockedIncrement( &AFSGlobalRoot->RootFcb->OpenHandleCount);
1319 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1320 AFS_TRACE_LEVEL_VERBOSE,
1321 "AFSOpenAFSRoot Increment handle count on Fcb %08lX Cnt %d\n",
1322 AFSGlobalRoot->RootFcb,
1325 *Fcb = AFSGlobalRoot->RootFcb;
1328 // Return the open result for this file
1331 Irp->IoStatus.Information = FILE_OPENED;
1342 AFSOpenRoot( IN PIRP Irp,
1343 IN AFSVolumeCB *VolumeCB,
1345 OUT AFSFcb **RootFcb,
1349 NTSTATUS ntStatus = STATUS_SUCCESS;
1350 PFILE_OBJECT pFileObject = NULL;
1351 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1352 PACCESS_MASK pDesiredAccess = NULL;
1353 USHORT usShareAccess;
1355 BOOLEAN bAllocatedCcb = FALSE;
1356 BOOLEAN bReleaseFcb = FALSE;
1357 AFSFileOpenCB stOpenCB;
1358 AFSFileOpenResultCB stOpenResultCB;
1359 ULONG ulResultLen = 0;
1365 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1366 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1367 ulOptions = pIrpSp->Parameters.Create.Options;
1369 pFileObject = pIrpSp->FileObject;
1371 if( BooleanFlagOn( ulOptions, FILE_NON_DIRECTORY_FILE))
1374 ntStatus = STATUS_FILE_IS_A_DIRECTORY;
1376 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1377 AFS_TRACE_LEVEL_ERROR,
1378 "AFSOpenRoot (%08lX) Attempt to open root as file Status %08lX\n",
1382 try_return( ntStatus);
1386 // Check if we should go and retrieve updated information for the node
1389 ntStatus = AFSValidateEntry( VolumeCB->DirectoryCB,
1393 if( !NT_SUCCESS( ntStatus))
1396 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1397 AFS_TRACE_LEVEL_ERROR,
1398 "AFSOpenRoot (%08lX) Failed to validate root entry Status %08lX\n",
1402 try_return( ntStatus);
1406 // Check with the service that we can open the file
1409 RtlZeroMemory( &stOpenCB,
1410 sizeof( AFSFileOpenCB));
1412 stOpenCB.DesiredAccess = *pDesiredAccess;
1414 stOpenCB.ShareAccess = usShareAccess;
1416 stOpenResultCB.GrantedAccess = 0;
1418 ulResultLen = sizeof( AFSFileOpenResultCB);
1420 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
1421 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
1424 &VolumeCB->ObjectInformation.FileId,
1426 sizeof( AFSFileOpenCB),
1427 (void *)&stOpenResultCB,
1430 if( !NT_SUCCESS( ntStatus))
1433 UNICODE_STRING uniGUID;
1436 uniGUID.MaximumLength = 0;
1437 uniGUID.Buffer = NULL;
1439 if( AuthGroup != NULL)
1441 RtlStringFromGUID( *AuthGroup,
1445 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1446 AFS_TRACE_LEVEL_ERROR,
1447 "AFSOpenRoot (%08lX) Failed open in service volume %08lX-%08lX AuthGroup %wZ Status %08lX\n",
1449 VolumeCB->ObjectInformation.FileId.Cell,
1450 VolumeCB->ObjectInformation.FileId.Volume,
1454 if( AuthGroup != NULL)
1456 RtlFreeUnicodeString( &uniGUID);
1459 try_return( ntStatus);
1463 // If the entry is not initialized then do it now
1466 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1469 AFSAcquireExcl( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
1472 if( !BooleanFlagOn( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
1475 ntStatus = AFSEnumerateDirectory( AuthGroup,
1476 &VolumeCB->ObjectInformation,
1479 if( !NT_SUCCESS( ntStatus))
1482 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1484 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1485 AFS_TRACE_LEVEL_ERROR,
1486 "AFSOpenRoot (%08lX) Failed to enumerate directory Status %08lX\n",
1490 try_return( ntStatus);
1493 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
1496 AFSReleaseResource( VolumeCB->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
1500 // If the root fcb has been initialized then check access otherwise
1501 // init the volume fcb
1504 if( VolumeCB->RootFcb == NULL)
1507 ntStatus = AFSInitRootFcb( (ULONGLONG)PsGetCurrentProcessId(),
1510 if( !NT_SUCCESS( ntStatus))
1513 try_return( ntStatus);
1519 AFSAcquireExcl( VolumeCB->RootFcb->Header.Resource,
1526 // If there are current opens on the Fcb, check the access.
1529 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1532 ntStatus = IoCheckShareAccess( *pDesiredAccess,
1535 &VolumeCB->RootFcb->ShareAccess,
1538 if( !NT_SUCCESS( ntStatus))
1541 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1542 AFS_TRACE_LEVEL_ERROR,
1543 "AFSOpenRoot (%08lX) Access check failure Status %08lX\n",
1547 try_return( ntStatus);
1552 // Initialize the Ccb for the file.
1555 ntStatus = AFSInitCcb( Ccb);
1557 if( !NT_SUCCESS( ntStatus))
1560 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1561 AFS_TRACE_LEVEL_ERROR,
1562 "AFSOpenRoot (%08lX) Failed to allocate Ccb Status %08lX\n",
1566 try_return( ntStatus);
1569 bAllocatedCcb = TRUE;
1575 (*Ccb)->DirectoryCB = VolumeCB->DirectoryCB;
1577 (*Ccb)->GrantedAccess = *pDesiredAccess;
1580 // OK, update the share access on the fileobject
1583 if( VolumeCB->RootFcb->OpenHandleCount > 0)
1586 IoUpdateShareAccess( pFileObject,
1587 &VolumeCB->RootFcb->ShareAccess);
1596 IoSetShareAccess( *pDesiredAccess,
1599 &VolumeCB->RootFcb->ShareAccess);
1603 // Increment the open count on this Fcb
1606 lCount = InterlockedIncrement( &VolumeCB->RootFcb->OpenReferenceCount);
1608 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1609 AFS_TRACE_LEVEL_VERBOSE,
1610 "AFSOpenRoot Increment count on Fcb %08lX Cnt %d\n",
1614 lCount = InterlockedIncrement( &VolumeCB->RootFcb->OpenHandleCount);
1616 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1617 AFS_TRACE_LEVEL_VERBOSE,
1618 "AFSOpenRoot Increment handle count on Fcb %08lX Cnt %d\n",
1623 // Indicate the object is held
1626 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_HELD_IN_SERVICE);
1629 // Return the open result for this file
1632 Irp->IoStatus.Information = FILE_OPENED;
1634 *RootFcb = VolumeCB->RootFcb;
1641 AFSReleaseResource( VolumeCB->RootFcb->Header.Resource);
1644 if( !NT_SUCCESS( ntStatus))
1656 Irp->IoStatus.Information = 0;
1664 AFSProcessCreate( IN PIRP Irp,
1666 IN AFSVolumeCB *VolumeCB,
1667 IN AFSDirectoryCB *ParentDirCB,
1668 IN PUNICODE_STRING FileName,
1669 IN PUNICODE_STRING ComponentName,
1670 IN PUNICODE_STRING FullFileName,
1675 NTSTATUS ntStatus = STATUS_SUCCESS;
1676 PFILE_OBJECT pFileObject = NULL;
1677 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1678 ULONG ulOptions = 0;
1679 ULONG ulShareMode = 0;
1681 ULONG ulAttributes = 0;
1682 LARGE_INTEGER liAllocationSize = {0,0};
1683 BOOLEAN bFileCreated = FALSE, bReleaseFcb = FALSE, bAllocatedCcb = FALSE;
1684 BOOLEAN bAllocatedFcb = FALSE;
1685 PACCESS_MASK pDesiredAccess = NULL;
1686 USHORT usShareAccess;
1687 AFSDirectoryCB *pDirEntry = NULL;
1688 AFSObjectInfoCB *pParentObjectInfo = NULL;
1689 AFSObjectInfoCB *pObjectInfo = NULL;
1695 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
1696 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
1698 pFileObject = pIrpSp->FileObject;
1701 // Extract out the options
1704 ulOptions = pIrpSp->Parameters.Create.Options;
1707 // We pass all attributes they want to apply to the file to the create
1710 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
1713 // If this is a directory create then set the attribute correctly
1716 if( ulOptions & FILE_DIRECTORY_FILE)
1719 ulAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1722 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1723 AFS_TRACE_LEVEL_VERBOSE,
1724 "AFSProcessCreate (%08lX) Creating file %wZ Attributes %08lX\n",
1729 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
1732 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1733 AFS_TRACE_LEVEL_ERROR,
1734 "AFSProcessCreate Request failed due to read only volume %wZ\n",
1737 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
1740 pParentObjectInfo = ParentDirCB->ObjectInformation;
1743 // Allocate and insert the direntry into the parent node
1746 ntStatus = AFSCreateDirEntry( AuthGroup,
1754 if( !NT_SUCCESS( ntStatus))
1757 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1758 AFS_TRACE_LEVEL_ERROR,
1759 "AFSProcessCreate (%08lX) Failed to create directory entry %wZ Status %08lX\n",
1764 try_return( ntStatus);
1767 bFileCreated = TRUE;
1769 pObjectInfo = pDirEntry->ObjectInformation;
1771 if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED) ||
1772 pObjectInfo->FileType == AFS_FILE_TYPE_UNKNOWN)
1775 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1776 AFS_TRACE_LEVEL_VERBOSE,
1777 "AFSProcessCreate (%08lX) Evaluating object %wZ FID %08lX-%08lX-%08lX-%08lX\n",
1779 &pDirEntry->NameInformation.FileName,
1780 pObjectInfo->FileId.Cell,
1781 pObjectInfo->FileId.Volume,
1782 pObjectInfo->FileId.Vnode,
1783 pObjectInfo->FileId.Unique);
1785 ntStatus = AFSEvaluateNode( AuthGroup,
1788 if( !NT_SUCCESS( ntStatus))
1791 if ( ntStatus == STATUS_NOT_A_DIRECTORY)
1794 if ( pParentObjectInfo == pObjectInfo->ParentObjectInformation)
1797 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1798 AFS_TRACE_LEVEL_ERROR,
1799 "AFSProcessCreate (%08lX) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1801 &pDirEntry->NameInformation.FileName,
1802 pObjectInfo->FileId.Cell,
1803 pObjectInfo->FileId.Volume,
1804 pObjectInfo->FileId.Vnode,
1805 pObjectInfo->FileId.Unique,
1806 pParentObjectInfo->FileId.Cell,
1807 pParentObjectInfo->FileId.Volume,
1808 pParentObjectInfo->FileId.Vnode,
1809 pParentObjectInfo->FileId.Unique,
1812 else if ( pObjectInfo->ParentObjectInformation == NULL)
1815 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1816 AFS_TRACE_LEVEL_ERROR,
1817 "AFSProcessCreate (%08lX) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX != NULL Status %08lX\n",
1819 &pDirEntry->NameInformation.FileName,
1820 pObjectInfo->FileId.Cell,
1821 pObjectInfo->FileId.Volume,
1822 pObjectInfo->FileId.Vnode,
1823 pObjectInfo->FileId.Unique,
1824 pParentObjectInfo->FileId.Cell,
1825 pParentObjectInfo->FileId.Volume,
1826 pParentObjectInfo->FileId.Vnode,
1827 pParentObjectInfo->FileId.Unique,
1833 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1834 AFS_TRACE_LEVEL_ERROR,
1835 "AFSProcessCreate (%08lX) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX != %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1837 &pDirEntry->NameInformation.FileName,
1838 pObjectInfo->FileId.Cell,
1839 pObjectInfo->FileId.Volume,
1840 pObjectInfo->FileId.Vnode,
1841 pObjectInfo->FileId.Unique,
1842 pParentObjectInfo->FileId.Cell,
1843 pParentObjectInfo->FileId.Volume,
1844 pParentObjectInfo->FileId.Vnode,
1845 pParentObjectInfo->FileId.Unique,
1846 pObjectInfo->ParentObjectInformation->FileId.Cell,
1847 pObjectInfo->ParentObjectInformation->FileId.Volume,
1848 pObjectInfo->ParentObjectInformation->FileId.Vnode,
1849 pObjectInfo->ParentObjectInformation->FileId.Unique,
1856 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1857 AFS_TRACE_LEVEL_ERROR,
1858 "AFSProcessCreate (%08lX) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1860 &pDirEntry->NameInformation.FileName,
1861 pObjectInfo->FileId.Cell,
1862 pObjectInfo->FileId.Volume,
1863 pObjectInfo->FileId.Vnode,
1864 pObjectInfo->FileId.Unique,
1868 try_return( ntStatus);
1871 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
1875 // We may have raced and the Fcb is already created
1878 if( pObjectInfo->Fcb != NULL)
1881 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1882 AFS_TRACE_LEVEL_VERBOSE,
1883 "AFSProcessCreate (%08lX) Not allocating Fcb for file %wZ\n",
1887 *Fcb = pObjectInfo->Fcb;
1889 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
1896 // Allocate and initialize the Fcb for the file.
1899 ntStatus = AFSInitFcb( pDirEntry);
1901 *Fcb = pObjectInfo->Fcb;
1903 if( !NT_SUCCESS( ntStatus))
1906 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1907 AFS_TRACE_LEVEL_ERROR,
1908 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
1913 try_return( ntStatus);
1916 if ( ntStatus != STATUS_REPARSE)
1919 bAllocatedFcb = TRUE;
1922 ntStatus = STATUS_SUCCESS;
1926 // Increment the open count on this Fcb
1929 lCount = InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
1931 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1932 AFS_TRACE_LEVEL_VERBOSE,
1933 "AFSProcessCreate Increment count on Fcb %08lX Cnt %d\n",
1940 // Initialize the Ccb for the file.
1943 ntStatus = AFSInitCcb( Ccb);
1945 if( !NT_SUCCESS( ntStatus))
1948 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1949 AFS_TRACE_LEVEL_ERROR,
1950 "AFSProcessCreate (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
1955 try_return( ntStatus);
1958 bAllocatedCcb = TRUE;
1961 // Initialize the Ccb
1964 (*Ccb)->DirectoryCB = pDirEntry;
1966 (*Ccb)->GrantedAccess = *pDesiredAccess;
1969 // If this is a file, update the headers filesizes.
1972 if( (*Fcb)->Header.NodeTypeCode == AFS_FILE_FCB)
1976 // Update the sizes with the information passed in
1979 (*Fcb)->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
1980 (*Fcb)->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1981 (*Fcb)->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
1984 // Notify the system of the addition
1987 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
1989 (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
1990 (ULONG)FILE_ACTION_ADDED);
1992 (*Fcb)->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
1994 else if( (*Fcb)->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1998 // This is a new directory node so indicate it has been enumerated
2001 SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
2004 // And the parent directory entry
2007 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
2010 // Notify the system of the addition
2013 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
2015 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
2016 (ULONG)FILE_ACTION_ADDED);
2018 else if( (*Fcb)->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2019 (*Fcb)->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2020 (*Fcb)->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2021 (*Fcb)->Header.NodeTypeCode == AFS_INVALID_FCB)
2025 // And the parent directory entry
2028 KeQuerySystemTime( &pParentObjectInfo->ChangeTime);
2031 // Notify the system of the addition
2034 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
2036 (ULONG)FILE_NOTIFY_CHANGE_DIR_NAME,
2037 (ULONG)FILE_ACTION_ADDED);
2041 // Save off the access for the open
2044 IoSetShareAccess( *pDesiredAccess,
2047 &(*Fcb)->ShareAccess);
2049 lCount = InterlockedIncrement( &(*Fcb)->OpenHandleCount);
2051 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2052 AFS_TRACE_LEVEL_VERBOSE,
2053 "AFSProcessCreate Increment handle count on Fcb %08lX Cnt %d\n",
2058 // Increment the open reference and handle on the parent node
2061 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2063 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2064 AFS_TRACE_LEVEL_VERBOSE,
2065 "AFSProcessCreate Increment child open handle count on Parent object %08lX Cnt %d\n",
2066 pObjectInfo->ParentObjectInformation,
2069 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2071 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2072 AFS_TRACE_LEVEL_VERBOSE,
2073 "AFSProcessCreate Increment child open ref count on Parent object %08lX Cnt %d\n",
2074 pObjectInfo->ParentObjectInformation,
2077 if( ulOptions & FILE_DELETE_ON_CLOSE)
2081 // Mark it for delete on close
2084 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2085 AFS_TRACE_LEVEL_VERBOSE,
2086 "AFSProcessCreate (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
2091 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2095 // Indicate the object is locked in the service
2098 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
2101 // Return the open result for this file
2104 Irp->IoStatus.Information = FILE_CREATED;
2109 // If we created the Fcb we need to release the resources
2115 if( !NT_SUCCESS( ntStatus))
2118 // Decrement the open count on this Fcb
2121 lCount = InterlockedDecrement( &(*Fcb)->OpenReferenceCount);
2123 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2124 AFS_TRACE_LEVEL_VERBOSE,
2125 "AFSProcessCreate Decrement count on Fcb %08lX Cnt %d\n",
2130 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
2133 if( !NT_SUCCESS( ntStatus))
2139 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2140 AFS_TRACE_LEVEL_VERBOSE,
2141 "AFSProcessCreate Create failed, removing DE %p from aprent object %p Status %08lX\n",
2147 // Remove the dir entry from the parent
2150 AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
2153 SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
2155 AFSNotifyDelete( pDirEntry,
2160 // Decrement the reference added during initialization of the DE
2163 lCount = InterlockedDecrement( &pDirEntry->OpenReferenceCount);
2165 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2166 AFS_TRACE_LEVEL_VERBOSE,
2167 "AFSProcessCreate Decrement count on %wZ DE %p Cnt %d\n",
2168 &pDirEntry->NameInformation.FileName,
2173 // Pull the directory entry from the parent
2176 AFSRemoveDirNodeFromParent( pParentObjectInfo,
2178 FALSE); // Leave it in the enum list so the worker cleans it up
2181 // Tag the parent as needing verification
2184 SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2186 pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
2188 AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
2201 AFSRemoveFcb( &pObjectInfo->Fcb);
2214 AFSOpenTargetDirectory( IN PIRP Irp,
2215 IN AFSVolumeCB *VolumeCB,
2216 IN AFSDirectoryCB *ParentDirectoryCB,
2217 IN AFSDirectoryCB *TargetDirectoryCB,
2218 IN UNICODE_STRING *TargetName,
2223 NTSTATUS ntStatus = STATUS_SUCCESS;
2224 PFILE_OBJECT pFileObject = NULL;
2225 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2226 PACCESS_MASK pDesiredAccess = NULL;
2227 USHORT usShareAccess;
2228 BOOLEAN bAllocatedCcb = FALSE;
2229 BOOLEAN bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2230 AFSObjectInfoCB *pParentObject = NULL, *pTargetObject = NULL;
2231 UNICODE_STRING uniTargetName;
2237 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2238 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2240 pFileObject = pIrpSp->FileObject;
2242 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2243 AFS_TRACE_LEVEL_VERBOSE,
2244 "AFSOpenTargetDirectory (%08lX) Processing file %wZ\n",
2248 pParentObject = ParentDirectoryCB->ObjectInformation;
2250 if( pParentObject->FileType != AFS_FILE_TYPE_DIRECTORY)
2253 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2257 // Make sure we have an Fcb for the access
2260 if( pParentObject->Fcb != NULL)
2263 *Fcb = pParentObject->Fcb;
2265 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
2272 // Allocate and initialize the Fcb for the file.
2275 ntStatus = AFSInitFcb( ParentDirectoryCB);
2277 *Fcb = pParentObject->Fcb;
2279 if( !NT_SUCCESS( ntStatus))
2282 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2283 AFS_TRACE_LEVEL_ERROR,
2284 "AFSProcessCreate (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
2286 &ParentDirectoryCB->NameInformation.FileName,
2289 try_return( ntStatus);
2292 if ( ntStatus == STATUS_REPARSE)
2295 bAllocatedFcb = TRUE;
2298 ntStatus = STATUS_SUCCESS;
2302 // Increment the open count on this Fcb
2305 lCount = InterlockedIncrement( &pParentObject->Fcb->OpenReferenceCount);
2307 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2308 AFS_TRACE_LEVEL_VERBOSE,
2309 "AFSOpenTargetDirectory Increment count on Fcb %08lX Cnt %d\n",
2316 // If there are current opens on the Fcb, check the access.
2319 if( pParentObject->Fcb->OpenHandleCount > 0)
2322 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2325 &pParentObject->Fcb->ShareAccess,
2328 if( !NT_SUCCESS( ntStatus))
2331 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2332 AFS_TRACE_LEVEL_ERROR,
2333 "AFSOpenTargetDirectory (%08lX) Access check failure %wZ Status %08lX\n",
2335 &ParentDirectoryCB->NameInformation.FileName,
2338 try_return( ntStatus);
2343 // Initialize the Ccb for the file.
2346 ntStatus = AFSInitCcb( Ccb);
2348 if( !NT_SUCCESS( ntStatus))
2351 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2352 AFS_TRACE_LEVEL_ERROR,
2353 "AFSOpenTargetDirectory (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2355 &ParentDirectoryCB->NameInformation.FileName,
2358 try_return( ntStatus);
2361 bAllocatedCcb = TRUE;
2364 // Initialize the Ccb
2367 (*Ccb)->DirectoryCB = ParentDirectoryCB;
2369 (*Ccb)->GrantedAccess = *pDesiredAccess;
2371 if( TargetDirectoryCB != NULL &&
2372 FsRtlAreNamesEqual( &TargetDirectoryCB->NameInformation.FileName,
2378 Irp->IoStatus.Information = FILE_EXISTS;
2380 uniTargetName = TargetDirectoryCB->NameInformation.FileName;
2385 Irp->IoStatus.Information = FILE_DOES_NOT_EXIST;
2387 uniTargetName = *TargetName;
2391 // Update the filename in the fileobject for rename processing
2394 RtlCopyMemory( pFileObject->FileName.Buffer,
2395 uniTargetName.Buffer,
2396 uniTargetName.Length);
2398 pFileObject->FileName.Length = uniTargetName.Length;
2401 // OK, update the share access on the fileobject
2404 if( pParentObject->Fcb->OpenHandleCount > 0)
2407 IoUpdateShareAccess( pFileObject,
2408 &pParentObject->Fcb->ShareAccess);
2417 IoSetShareAccess( *pDesiredAccess,
2420 &pParentObject->Fcb->ShareAccess);
2423 lCount = InterlockedIncrement( &pParentObject->Fcb->OpenHandleCount);
2425 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2426 AFS_TRACE_LEVEL_VERBOSE,
2427 "AFSOpenTargetDirectory Increment handle count on Fcb %08lX Cnt %d\n",
2432 // Increment the open reference and handle on the parent node
2435 if( pParentObject->ParentObjectInformation != NULL)
2438 lCount = InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2440 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2441 AFS_TRACE_LEVEL_VERBOSE,
2442 "AFSOpenTargetDirectory Increment child open handle count on Parent object %08lX Cnt %d\n",
2443 pParentObject->ParentObjectInformation,
2446 lCount = InterlockedIncrement( &pParentObject->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2448 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2449 AFS_TRACE_LEVEL_VERBOSE,
2450 "AFSOpenTargetDirectory Increment child open ref count on Parent object %08lX Cnt %d\n",
2451 pParentObject->ParentObjectInformation,
2460 if( !NT_SUCCESS( ntStatus))
2463 // Decrement the open count on this Fcb
2466 lCount = InterlockedDecrement( &pParentObject->Fcb->OpenReferenceCount);
2468 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2469 AFS_TRACE_LEVEL_VERBOSE,
2470 "AFSOpenTargetDirectory Decrement count on Fcb %08lX Cnt %d\n",
2475 AFSReleaseResource( &pParentObject->Fcb->NPFcb->Resource);
2478 if( !NT_SUCCESS( ntStatus))
2493 AFSRemoveFcb( &pParentObject->Fcb);
2504 AFSProcessOpen( IN PIRP Irp,
2506 IN AFSVolumeCB *VolumeCB,
2507 IN AFSDirectoryCB *ParentDirCB,
2508 IN AFSDirectoryCB *DirectoryCB,
2513 NTSTATUS ntStatus = STATUS_SUCCESS;
2514 PFILE_OBJECT pFileObject = NULL;
2515 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2516 PACCESS_MASK pDesiredAccess = NULL;
2517 USHORT usShareAccess;
2518 BOOLEAN bAllocatedCcb = FALSE, bReleaseFcb = FALSE, bAllocatedFcb = FALSE;
2519 ULONG ulAdditionalFlags = 0, ulOptions = 0;
2520 AFSFileOpenCB stOpenCB;
2521 AFSFileOpenResultCB stOpenResultCB;
2522 ULONG ulResultLen = 0;
2523 AFSObjectInfoCB *pParentObjectInfo = NULL;
2524 AFSObjectInfoCB *pObjectInfo = NULL;
2525 ULONG ulFileAccess = 0;
2526 AFSFileAccessReleaseCB stReleaseFileAccess;
2532 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
2533 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
2535 pFileObject = pIrpSp->FileObject;
2537 pParentObjectInfo = ParentDirCB->ObjectInformation;
2539 pObjectInfo = DirectoryCB->ObjectInformation;
2542 // Check if the entry is pending a deletion
2545 if( BooleanFlagOn( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
2548 ntStatus = STATUS_DELETE_PENDING;
2550 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2551 AFS_TRACE_LEVEL_ERROR,
2552 "AFSProcessOpen (%08lX) Entry pending delete %wZ Status %08lX\n",
2554 &DirectoryCB->NameInformation.FileName,
2557 try_return( ntStatus);
2561 // Extract out the options
2564 ulOptions = pIrpSp->Parameters.Create.Options;
2567 // Check if we should go and retrieve updated information for the node
2570 ntStatus = AFSValidateEntry( DirectoryCB,
2574 if( !NT_SUCCESS( ntStatus))
2577 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2578 AFS_TRACE_LEVEL_ERROR,
2579 "AFSProcessOpen (%08lX) Failed to validate entry %wZ Status %08lX\n",
2581 &DirectoryCB->NameInformation.FileName,
2584 try_return( ntStatus);
2588 // If this is marked for delete on close then be sure we can delete the entry
2591 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2594 ntStatus = AFSNotifyDelete( DirectoryCB,
2598 if( !NT_SUCCESS( ntStatus))
2601 ntStatus = STATUS_CANNOT_DELETE;
2603 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2604 AFS_TRACE_LEVEL_ERROR,
2605 "AFSProcessOpen (%08lX) Cannot delete entry %wZ marked for delete on close Status %08lX\n",
2607 &DirectoryCB->NameInformation.FileName,
2610 try_return( ntStatus);
2615 // Be sure we have an Fcb for the current object
2618 if( pObjectInfo->Fcb == NULL)
2621 ntStatus = AFSInitFcb( DirectoryCB);
2623 if( !NT_SUCCESS( ntStatus))
2626 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2627 AFS_TRACE_LEVEL_ERROR,
2628 "AFSProcessOpen (%08lX) Failed to init fcb on %wZ Status %08lX\n",
2630 &DirectoryCB->NameInformation.FileName,
2633 try_return( ntStatus);
2636 if ( ntStatus != STATUS_REPARSE)
2639 bAllocatedFcb = TRUE;
2642 ntStatus = STATUS_SUCCESS;
2647 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
2652 // Increment the open count on this Fcb
2655 lCount = InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
2657 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2658 AFS_TRACE_LEVEL_VERBOSE,
2659 "AFSProcessOpen Increment2 count on Fcb %08lX Cnt %d\n",
2666 // Check access on the entry
2669 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2672 ntStatus = IoCheckShareAccess( *pDesiredAccess,
2675 &pObjectInfo->Fcb->ShareAccess,
2678 if( !NT_SUCCESS( ntStatus))
2681 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2682 AFS_TRACE_LEVEL_ERROR,
2683 "AFSProcessOpen (%08lX) Failed to check share access on %wZ Status %08lX\n",
2685 &DirectoryCB->NameInformation.FileName,
2688 try_return( ntStatus);
2693 // Additional checks
2696 if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_FILE_FCB)
2700 // If the caller is asking for write access then try to flush the image section
2703 if( FlagOn( *pDesiredAccess, FILE_WRITE_DATA) ||
2704 BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE))
2707 if( !MmFlushImageSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2711 ntStatus = BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE) ? STATUS_CANNOT_DELETE :
2712 STATUS_SHARING_VIOLATION;
2714 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2715 AFS_TRACE_LEVEL_ERROR,
2716 "AFSProcessOpen (%08lX) Failed to flush image section %wZ Status %08lX\n",
2718 &DirectoryCB->NameInformation.FileName,
2721 try_return( ntStatus);
2725 if( BooleanFlagOn( ulOptions, FILE_DIRECTORY_FILE))
2728 ntStatus = STATUS_NOT_A_DIRECTORY;
2730 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2731 AFS_TRACE_LEVEL_ERROR,
2732 "AFSProcessOpen (%08lX) Attempt to open file as directory %wZ Status %08lX\n",
2734 &DirectoryCB->NameInformation.FileName,
2737 try_return( ntStatus);
2740 pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
2742 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB ||
2743 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2746 if( BooleanFlagOn( ulOptions, FILE_NON_DIRECTORY_FILE))
2749 ntStatus = STATUS_FILE_IS_A_DIRECTORY;
2751 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2752 AFS_TRACE_LEVEL_ERROR,
2753 "AFSProcessOpen (%08lX) Attempt to open directory as file %wZ Status %08lX\n",
2755 &DirectoryCB->NameInformation.FileName,
2758 try_return( ntStatus);
2761 else if( pObjectInfo->Fcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2762 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2763 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2764 pObjectInfo->Fcb->Header.NodeTypeCode == AFS_INVALID_FCB)
2771 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2775 // Check with the service that we can open the file
2778 stOpenCB.ParentId = pParentObjectInfo->FileId;
2780 stOpenCB.DesiredAccess = *pDesiredAccess;
2782 stOpenCB.ShareAccess = usShareAccess;
2784 stOpenCB.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
2786 stOpenCB.Identifier = (ULONGLONG)pFileObject;
2788 stOpenResultCB.GrantedAccess = 0;
2790 ulResultLen = sizeof( AFSFileOpenResultCB);
2792 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_OPEN_FILE,
2793 AFS_REQUEST_FLAG_SYNCHRONOUS | AFS_REQUEST_FLAG_HOLD_FID,
2795 &DirectoryCB->NameInformation.FileName,
2796 &pObjectInfo->FileId,
2798 sizeof( AFSFileOpenCB),
2799 (void *)&stOpenResultCB,
2802 if( !NT_SUCCESS( ntStatus))
2805 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2806 AFS_TRACE_LEVEL_ERROR,
2807 "AFSProcessOpen (%08lX) Failed open in service %wZ Status %08lX\n",
2809 &DirectoryCB->NameInformation.FileName,
2812 try_return( ntStatus);
2816 // Save the granted access in case we need to release it below
2819 ulFileAccess = stOpenResultCB.FileAccess;
2822 // Check if there is a conflict
2825 if( !AFSCheckAccess( *pDesiredAccess,
2826 stOpenResultCB.GrantedAccess,
2827 BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY)))
2830 ntStatus = STATUS_ACCESS_DENIED;
2832 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2833 AFS_TRACE_LEVEL_ERROR,
2834 "AFSProcessOpen (%08lX) Failed to check access from service Desired %08lX Granted %08lX Entry %wZ Status %08lX\n",
2837 stOpenResultCB.GrantedAccess,
2838 &DirectoryCB->NameInformation.FileName,
2841 try_return( ntStatus);
2845 // Initialize the Ccb for the file.
2848 ntStatus = AFSInitCcb( Ccb);
2850 if( !NT_SUCCESS( ntStatus))
2853 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2854 AFS_TRACE_LEVEL_ERROR,
2855 "AFSProcessOpen (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
2857 &DirectoryCB->NameInformation.FileName,
2860 try_return( ntStatus);
2863 bAllocatedCcb = TRUE;
2865 (*Ccb)->DirectoryCB = DirectoryCB;
2867 (*Ccb)->FileAccess = ulFileAccess;
2869 (*Ccb)->GrantedAccess = *pDesiredAccess;
2872 // Perform the access check on the target if this is a mount point or symlink
2875 if( pObjectInfo->Fcb->OpenHandleCount > 0)
2878 IoUpdateShareAccess( pFileObject,
2879 &pObjectInfo->Fcb->ShareAccess);
2888 IoSetShareAccess( *pDesiredAccess,
2891 &pObjectInfo->Fcb->ShareAccess);
2894 lCount = InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
2896 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2897 AFS_TRACE_LEVEL_VERBOSE,
2898 "AFSProcessOpen Increment handle count on Fcb %08lX Cnt %d\n",
2903 // Increment the open reference and handle on the parent node
2906 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2908 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2909 AFS_TRACE_LEVEL_VERBOSE,
2910 "AFSProcessOpen Increment child open handle count on Parent object %08lX Cnt %d\n",
2911 pObjectInfo->ParentObjectInformation,
2914 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2916 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2917 AFS_TRACE_LEVEL_VERBOSE,
2918 "AFSProcessOpen Increment child open ref count on Parent object %08lX Cnt %d\n",
2919 pObjectInfo->ParentObjectInformation,
2922 if( BooleanFlagOn( ulOptions, FILE_DELETE_ON_CLOSE))
2926 // Mark it for delete on close
2929 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2930 AFS_TRACE_LEVEL_VERBOSE,
2931 "AFSProcessOpen (%08lX) Setting PENDING_DELETE flag in DirEntry %p Name %wZ\n",
2934 &DirectoryCB->NameInformation.FileName);
2936 SetFlag( DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2940 // Indicate the object is held
2943 SetFlag( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
2946 // Return the open result for this file
2949 Irp->IoStatus.Information = FILE_OPENED;
2951 *Fcb = pObjectInfo->Fcb;
2958 if( !NT_SUCCESS( ntStatus))
2961 // Decrement the open count on this Fcb
2964 lCount = InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
2966 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
2967 AFS_TRACE_LEVEL_VERBOSE,
2968 "AFSProcessOpen Decrement2 count on Fcb %08lX Cnt %d\n",
2973 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
2976 if( !NT_SUCCESS( ntStatus))
2979 if ( ulFileAccess > 0)
2982 stReleaseFileAccess.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
2984 stReleaseFileAccess.FileAccess = ulFileAccess;
2986 stReleaseFileAccess.Identifier = (ULONGLONG)pFileObject;
2988 AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_ACCESS,
2989 AFS_REQUEST_FLAG_SYNCHRONOUS,
2991 &DirectoryCB->NameInformation.FileName,
2992 &pObjectInfo->FileId,
2993 (void *)&stReleaseFileAccess,
2994 sizeof( AFSFileAccessReleaseCB),
3011 AFSRemoveFcb( &pObjectInfo->Fcb);
3022 AFSProcessOverwriteSupersede( IN PDEVICE_OBJECT DeviceObject,
3024 IN AFSVolumeCB *VolumeCB,
3026 IN AFSDirectoryCB *ParentDirCB,
3027 IN AFSDirectoryCB *DirectoryCB,
3032 NTSTATUS ntStatus = STATUS_SUCCESS;
3033 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3034 PFILE_OBJECT pFileObject = NULL;
3035 LARGE_INTEGER liZero = {0,0};
3036 BOOLEAN bReleasePaging = FALSE, bReleaseFcb = FALSE;
3037 ULONG ulAttributes = 0;
3038 LARGE_INTEGER liTime;
3039 ULONG ulCreateDisposition = 0;
3040 BOOLEAN bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
3041 PACCESS_MASK pDesiredAccess = NULL;
3042 USHORT usShareAccess;
3043 AFSObjectInfoCB *pParentObjectInfo = NULL;
3044 AFSObjectInfoCB *pObjectInfo = NULL;
3046 LARGE_INTEGER liSaveSize;
3047 LARGE_INTEGER liSaveVDL;
3048 LARGE_INTEGER liSaveAlloc;
3053 pDesiredAccess = &pIrpSp->Parameters.Create.SecurityContext->DesiredAccess;
3055 usShareAccess = pIrpSp->Parameters.Create.ShareAccess;
3057 pFileObject = pIrpSp->FileObject;
3059 ulAttributes = pIrpSp->Parameters.Create.FileAttributes;
3061 ulCreateDisposition = (pIrpSp->Parameters.Create.Options >> 24) & 0x000000ff;
3063 if( BooleanFlagOn( VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
3066 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3067 AFS_TRACE_LEVEL_ERROR,
3068 "AFSProcessOverwriteSupersede Request failed on %wZ due to read only volume\n",
3070 &DirectoryCB->NameInformation.FileName);
3072 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
3075 pParentObjectInfo = ParentDirCB->ObjectInformation;
3077 pObjectInfo = DirectoryCB->ObjectInformation;
3080 // Check if we should go and retrieve updated information for the node
3083 ntStatus = AFSValidateEntry( DirectoryCB,
3087 if( !NT_SUCCESS( ntStatus))
3090 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3091 AFS_TRACE_LEVEL_ERROR,
3092 "AFSProcessOverwriteSupersede (%08lX) Failed to validate entry %wZ Status %08lX\n",
3094 &DirectoryCB->NameInformation.FileName,
3097 try_return( ntStatus);
3101 // Be sure we have an Fcb for the object block
3104 if( pObjectInfo->Fcb == NULL)
3107 ntStatus = AFSInitFcb( DirectoryCB);
3109 *Fcb = pObjectInfo->Fcb;
3111 if( !NT_SUCCESS( ntStatus))
3114 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3115 AFS_TRACE_LEVEL_ERROR,
3116 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize fcb %wZ Status %08lX\n",
3118 &DirectoryCB->NameInformation.FileName,
3121 try_return( ntStatus);
3124 if ( ntStatus != STATUS_REPARSE)
3127 bAllocatedFcb = TRUE;
3130 ntStatus = STATUS_SUCCESS;
3135 AFSAcquireExcl( pObjectInfo->Fcb->Header.Resource,
3140 // Increment the open count on this Fcb.
3143 lCount = InterlockedIncrement( &pObjectInfo->Fcb->OpenReferenceCount);
3145 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3146 AFS_TRACE_LEVEL_VERBOSE,
3147 "AFSProcessOverwriteSupersede Increment2 count on Fcb %08lX Cnt %d\n",
3154 // Check access on the entry
3157 if( pObjectInfo->Fcb->OpenHandleCount > 0)
3160 ntStatus = IoCheckShareAccess( *pDesiredAccess,
3163 &pObjectInfo->Fcb->ShareAccess,
3166 if( !NT_SUCCESS( ntStatus))
3169 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3170 AFS_TRACE_LEVEL_ERROR,
3171 "AFSProcessOverwriteSupersede (%08lX) Access check failure %wZ Status %08lX\n",
3173 &DirectoryCB->NameInformation.FileName,
3176 try_return( ntStatus);
3181 // Before we actually truncate, check to see if the purge
3182 // is going to fail.
3185 if( !MmCanFileBeTruncated( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
3189 ntStatus = STATUS_USER_MAPPED_FILE;
3191 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3192 AFS_TRACE_LEVEL_ERROR,
3193 "AFSProcessOverwriteSupersede (%08lX) File user mapped %wZ Status %08lX\n",
3195 &DirectoryCB->NameInformation.FileName,
3198 try_return( ntStatus);
3202 // Initialize the Ccb for the file.
3205 ntStatus = AFSInitCcb( Ccb);
3207 if( !NT_SUCCESS( ntStatus))
3210 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3211 AFS_TRACE_LEVEL_ERROR,
3212 "AFSProcessOverwriteSupersede (%08lX) Failed to initialize ccb %wZ Status %08lX\n",
3214 &DirectoryCB->NameInformation.FileName,
3217 try_return( ntStatus);
3220 bAllocatedCcb = TRUE;
3223 // Initialize the Ccb
3226 (*Ccb)->DirectoryCB = DirectoryCB;
3228 (*Ccb)->GrantedAccess = *pDesiredAccess;
3231 // Set the file length to zero
3234 AFSAcquireExcl( pObjectInfo->Fcb->Header.PagingIoResource,
3237 bReleasePaging = TRUE;
3239 liSaveSize = pObjectInfo->Fcb->Header.FileSize;
3240 liSaveAlloc = pObjectInfo->Fcb->Header.AllocationSize;
3241 liSaveVDL = pObjectInfo->Fcb->Header.ValidDataLength;
3243 pObjectInfo->Fcb->Header.FileSize.QuadPart = 0;
3244 pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = 0;
3245 pObjectInfo->Fcb->Header.AllocationSize.QuadPart = 0;
3247 pObjectInfo->EndOfFile.QuadPart = 0;
3248 pObjectInfo->AllocationSize.QuadPart = 0;
3251 // Trim down the extents. We do this BEFORE telling the service
3252 // the file is truncated since there is a potential race between
3253 // a worker thread releasing extents and us trimming
3256 AFSTrimExtents( pObjectInfo->Fcb,
3257 &pObjectInfo->Fcb->Header.FileSize);
3259 KeQuerySystemTime( &pObjectInfo->ChangeTime);
3261 KeQuerySystemTime( &pObjectInfo->LastAccessTime);
3263 KeQuerySystemTime( &pObjectInfo->LastWriteTime);
3266 // Set the update flag accordingly
3269 SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED |
3270 AFS_FCB_FLAG_UPDATE_CREATE_TIME |
3271 AFS_FCB_FLAG_UPDATE_CHANGE_TIME |
3272 AFS_FCB_FLAG_UPDATE_ACCESS_TIME |
3273 AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
3275 ntStatus = AFSUpdateFileInformation( &pParentObjectInfo->FileId,
3279 if( !NT_SUCCESS( ntStatus))
3282 pObjectInfo->Fcb->Header.ValidDataLength = liSaveVDL;
3283 pObjectInfo->Fcb->Header.FileSize = liSaveSize;
3284 pObjectInfo->Fcb->Header.AllocationSize = liSaveAlloc;
3285 pObjectInfo->Fcb->ObjectInformation->EndOfFile = liSaveSize;
3286 pObjectInfo->Fcb->ObjectInformation->AllocationSize = liSaveAlloc;
3288 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3289 AFS_TRACE_LEVEL_ERROR,
3290 "AFSProcessOverwriteSupersede (%08lX) Failed to update file information %wZ Status %08lX\n",
3292 &DirectoryCB->NameInformation.FileName,
3295 try_return( ntStatus);
3298 ulAttributes |= FILE_ATTRIBUTE_ARCHIVE;
3300 if( ulCreateDisposition == FILE_SUPERSEDE)
3303 pObjectInfo->FileAttributes = ulAttributes;
3309 pObjectInfo->FileAttributes |= ulAttributes;
3313 // Save off the access for the open
3316 if( pObjectInfo->Fcb->OpenHandleCount > 0)
3319 IoUpdateShareAccess( pFileObject,
3320 &pObjectInfo->Fcb->ShareAccess);
3329 IoSetShareAccess( *pDesiredAccess,
3332 &pObjectInfo->Fcb->ShareAccess);
3336 // Return the correct action
3339 if( ulCreateDisposition == FILE_SUPERSEDE)
3342 Irp->IoStatus.Information = FILE_SUPERSEDED;
3347 Irp->IoStatus.Information = FILE_OVERWRITTEN;
3350 lCount = InterlockedIncrement( &pObjectInfo->Fcb->OpenHandleCount);
3352 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3353 AFS_TRACE_LEVEL_VERBOSE,
3354 "AFSProcessOverwriteSupersede Increment handle count on Fcb %08lX Cnt %d\n",
3359 // Increment the open reference and handle on the parent node
3362 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3364 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3365 AFS_TRACE_LEVEL_VERBOSE,
3366 "AFSProcessOverwriteSupersede Increment child open handle count on Parent object %08lX Cnt %d\n",
3367 pObjectInfo->ParentObjectInformation,
3370 lCount = InterlockedIncrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3372 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3373 AFS_TRACE_LEVEL_VERBOSE,
3374 "AFSProcessOverwriteSupersede Increment child open ref count on Parent object %08lX Cnt %d\n",
3375 pObjectInfo->ParentObjectInformation,
3378 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
3380 bReleaseFcb = FALSE;
3382 *Fcb = pObjectInfo->Fcb;
3385 // Now that the Fcb->Resource has been dropped
3386 // we can call CcSetFileSizes. We are still holding
3387 // the PagingIoResource
3390 pFileObject->SectionObjectPointer = &pObjectInfo->Fcb->NPFcb->SectionObjectPointers;
3392 pFileObject->FsContext = (void *)pObjectInfo->Fcb;
3394 pFileObject->FsContext2 = (void *)*Ccb;
3396 CcSetFileSizes( pFileObject,
3397 (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
3404 AFSReleaseResource( pObjectInfo->Fcb->Header.PagingIoResource);
3410 if( !NT_SUCCESS( ntStatus))
3413 // Decrement the open count on this Fcb.
3416 lCount = InterlockedDecrement( &pObjectInfo->Fcb->OpenReferenceCount);
3418 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3419 AFS_TRACE_LEVEL_VERBOSE,
3420 "AFSProcessOverwriteSupersede Decrement2 count on Fcb %08lX Cnt %d\n",
3425 AFSReleaseResource( pObjectInfo->Fcb->Header.Resource);
3428 if( !NT_SUCCESS( ntStatus))
3443 AFSRemoveFcb( &pObjectInfo->Fcb);
3454 AFSControlDeviceCreate( IN PIRP Irp)
3457 NTSTATUS ntStatus = STATUS_SUCCESS;
3463 // For now, jsut let the open happen
3466 Irp->IoStatus.Information = FILE_OPENED;
3473 AFSOpenIOCtlFcb( IN PIRP Irp,
3475 IN AFSDirectoryCB *ParentDirCB,
3480 NTSTATUS ntStatus = STATUS_SUCCESS;
3481 PFILE_OBJECT pFileObject = NULL;
3482 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3483 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocatedFcb = FALSE;
3484 UNICODE_STRING uniFullFileName;
3485 AFSPIOCtlOpenCloseRequestCB stPIOCtlOpen;
3487 AFSObjectInfoCB *pParentObjectInfo = NULL;
3493 pFileObject = pIrpSp->FileObject;
3495 pParentObjectInfo = ParentDirCB->ObjectInformation;
3498 // If we haven't initialized the PIOCtl DirectoryCB for this directory then do it now
3501 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB == NULL)
3504 ntStatus = AFSInitPIOCtlDirectoryCB( pParentObjectInfo);
3506 if( !NT_SUCCESS( ntStatus))
3509 try_return( ntStatus);
3513 if( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb == NULL)
3517 // Allocate and initialize the Fcb for the file.
3520 ntStatus = AFSInitFcb( pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB);
3522 *Fcb = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb;
3524 if( !NT_SUCCESS( ntStatus))
3527 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3528 AFS_TRACE_LEVEL_ERROR,
3529 "AFSOpenIOCtlFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3533 try_return( ntStatus);
3536 if ( ntStatus != STATUS_REPARSE)
3539 bAllocatedFcb = TRUE;
3542 ntStatus = STATUS_SUCCESS;
3547 *Fcb = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb;
3549 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3554 // Increment the open reference and handle on the node
3557 lCount = InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3559 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3560 AFS_TRACE_LEVEL_VERBOSE,
3561 "AFSOpenIOCtlFcb Increment count on Fcb %08lX Cnt %d\n",
3568 // Initialize the Ccb for the file.
3571 ntStatus = AFSInitCcb( Ccb);
3573 if( !NT_SUCCESS( ntStatus))
3576 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3577 AFS_TRACE_LEVEL_ERROR,
3578 "AFSOpenIOCtlFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3582 try_return( ntStatus);
3585 bAllocatedCcb = TRUE;
3591 (*Ccb)->DirectoryCB = pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB;
3594 // Set the PIOCtl index
3597 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3599 RtlZeroMemory( &stPIOCtlOpen,
3600 sizeof( AFSPIOCtlOpenCloseRequestCB));
3602 stPIOCtlOpen.RequestId = (*Ccb)->RequestID;
3604 stPIOCtlOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3606 RtlZeroMemory( &stFileID,
3607 sizeof( AFSFileID));
3610 // The parent directory FID of the node
3613 stFileID = pParentObjectInfo->FileId;
3616 // Issue the open request to the service
3619 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_OPEN,
3620 AFS_REQUEST_FLAG_SYNCHRONOUS,
3624 (void *)&stPIOCtlOpen,
3625 sizeof( AFSPIOCtlOpenCloseRequestCB),
3629 if( !NT_SUCCESS( ntStatus))
3632 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3633 AFS_TRACE_LEVEL_ERROR,
3634 "AFSOpenIOCtlFcb (%08lX) Failed service open Status %08lX\n",
3638 try_return( ntStatus);
3642 // Reference the directory entry
3645 lCount = InterlockedIncrement( &((*Ccb)->DirectoryCB->OpenReferenceCount));
3647 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3648 AFS_TRACE_LEVEL_VERBOSE,
3649 "AFSOpenIOCtlFcb Increment count on %wZ DE %p Ccb %p Cnt %d\n",
3650 &(*Ccb)->DirectoryCB->NameInformation.FileName,
3651 (*Ccb)->DirectoryCB,
3656 // Increment the handle on the node
3659 lCount = InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3661 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3662 AFS_TRACE_LEVEL_VERBOSE,
3663 "AFSOpenIOCtlFcb Increment handle count on Fcb %08lX Cnt %d\n",
3668 // Increment the open reference and handle on the parent node
3671 lCount = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3673 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3674 AFS_TRACE_LEVEL_VERBOSE,
3675 "AFSOpenIOCtlFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3679 lCount = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3681 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3682 AFS_TRACE_LEVEL_VERBOSE,
3683 "AFSOpenIOCtlFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3688 // Return the open result for this file
3691 Irp->IoStatus.Information = FILE_OPENED;
3696 //Dereference the passed in parent since the returned dir entry
3697 // is already referenced
3700 lCount = InterlockedDecrement( &ParentDirCB->OpenReferenceCount);
3702 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3703 AFS_TRACE_LEVEL_VERBOSE,
3704 "AFSOpenIOCtlFcb Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3705 &ParentDirCB->NameInformation.FileName,
3711 // If we created the Fcb we need to release the resources
3717 if( !NT_SUCCESS( ntStatus))
3720 // Decrement the open reference and handle on the node
3723 lCount = InterlockedDecrement( &(*Fcb)->OpenReferenceCount);
3725 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3726 AFS_TRACE_LEVEL_VERBOSE,
3727 "AFSOpenIOCtlFcb Decrement count on Fcb %08lX Cnt %d\n",
3732 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3735 if( !NT_SUCCESS( ntStatus))
3751 // Need to tear down this Fcb since it is not in the tree for the worker thread
3754 AFSRemoveFcb( &pParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
3765 AFSOpenSpecialShareFcb( IN PIRP Irp,
3767 IN AFSDirectoryCB *DirectoryCB,
3772 NTSTATUS ntStatus = STATUS_SUCCESS;
3773 PFILE_OBJECT pFileObject = NULL;
3774 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3775 BOOLEAN bReleaseFcb = FALSE, bAllocatedCcb = FALSE, bAllocateFcb = FALSE;
3776 AFSObjectInfoCB *pParentObjectInfo = NULL;
3777 AFSPipeOpenCloseRequestCB stPipeOpen;
3783 pFileObject = pIrpSp->FileObject;
3785 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3786 AFS_TRACE_LEVEL_VERBOSE_2,
3787 "AFSOpenSpecialShareFcb (%08lX) Processing Share %wZ open\n",
3789 &DirectoryCB->NameInformation.FileName);
3791 pParentObjectInfo = DirectoryCB->ObjectInformation->ParentObjectInformation;
3793 if( DirectoryCB->ObjectInformation->Fcb == NULL)
3797 // Allocate and initialize the Fcb for the file.
3800 ntStatus = AFSInitFcb( DirectoryCB);
3802 *Fcb = DirectoryCB->ObjectInformation->Fcb;
3804 if( !NT_SUCCESS( ntStatus))
3807 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3808 AFS_TRACE_LEVEL_ERROR,
3809 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize fcb Status %08lX\n",
3813 try_return( ntStatus);
3816 if ( ntStatus != STATUS_REPARSE)
3819 bAllocateFcb = TRUE;
3822 ntStatus = STATUS_SUCCESS;
3827 *Fcb = DirectoryCB->ObjectInformation->Fcb;
3829 AFSAcquireExcl( &(*Fcb)->NPFcb->Resource,
3834 // Increment the open count on this Fcb
3837 lCount = InterlockedIncrement( &(*Fcb)->OpenReferenceCount);
3839 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3840 AFS_TRACE_LEVEL_VERBOSE,
3841 "AFSOpenSpecialShareFcb Increment count on Fcb %08lX Cnt %d\n",
3848 // Initialize the Ccb for the file.
3851 ntStatus = AFSInitCcb( Ccb);
3853 if( !NT_SUCCESS( ntStatus))
3856 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3857 AFS_TRACE_LEVEL_ERROR,
3858 "AFSOpenSpecialShareFcb (%08lX) Failed to initialize ccb Status %08lX\n",
3862 try_return( ntStatus);
3865 bAllocatedCcb = TRUE;
3871 (*Ccb)->DirectoryCB = DirectoryCB;
3874 // Call the service to open the share
3877 (*Ccb)->RequestID = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.OpenRequestIndex);
3879 RtlZeroMemory( &stPipeOpen,
3880 sizeof( AFSPipeOpenCloseRequestCB));
3882 stPipeOpen.RequestId = (*Ccb)->RequestID;
3884 stPipeOpen.RootId = pParentObjectInfo->VolumeCB->ObjectInformation.FileId;
3887 // Issue the open request to the service
3890 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_OPEN,
3891 AFS_REQUEST_FLAG_SYNCHRONOUS,
3893 &DirectoryCB->NameInformation.FileName,
3895 (void *)&stPipeOpen,
3896 sizeof( AFSPipeOpenCloseRequestCB),
3900 if( !NT_SUCCESS( ntStatus))
3903 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3904 AFS_TRACE_LEVEL_ERROR,
3905 "AFSOpenSpecialShareFcb (%08lX) Failed service open Status %08lX\n",
3909 try_return( ntStatus);
3912 lCount = InterlockedIncrement( &(*Fcb)->OpenHandleCount);
3914 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3915 AFS_TRACE_LEVEL_VERBOSE,
3916 "AFSOpenSpecialShareFcb Increment handle count on Fcb %08lX Cnt %d\n",
3921 // Increment the open reference and handle on the parent node
3924 lCount = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenHandleCount);
3926 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3927 AFS_TRACE_LEVEL_VERBOSE,
3928 "AFSOpenSpecialShareFcb Increment child open handle count on Parent object %08lX Cnt %d\n",
3932 lCount = InterlockedIncrement( &pParentObjectInfo->Specific.Directory.ChildOpenReferenceCount);
3934 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3935 AFS_TRACE_LEVEL_VERBOSE,
3936 "AFSOpenSpecialShareFcb Increment child open ref count on Parent object %08lX Cnt %d\n",
3941 // Return the open result for this file
3944 Irp->IoStatus.Information = FILE_OPENED;
3951 if( !NT_SUCCESS( ntStatus))
3954 // Decrement the open count on this Fcb
3957 lCount = InterlockedDecrement( &(*Fcb)->OpenReferenceCount);
3959 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
3960 AFS_TRACE_LEVEL_VERBOSE,
3961 "AFSOpenSpecialShareFcb Decrement count on Fcb %08lX Cnt %d\n",
3966 AFSReleaseResource( &(*Fcb)->NPFcb->Resource);
3969 if( !NT_SUCCESS( ntStatus))
3985 // Need to tear down this Fcb since it is not in the tree for the worker thread
3988 AFSRemoveFcb( &DirectoryCB->ObjectInformation->Fcb);