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: AFSFileInfo.cpp
39 #include "AFSCommon.h"
42 // Function: AFSQueryFileInfo
46 // This function is the dispatch handler for the IRP_MJ_QUERY_FILE_INFORMATION request
50 // A status is returned for the function
54 AFSQueryFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
58 UNREFERENCED_PARAMETER(LibDeviceObject);
59 NTSTATUS ntStatus = STATUS_SUCCESS;
60 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
63 BOOLEAN bReleaseMain = FALSE;
65 FILE_INFORMATION_CLASS stFileInformationClass;
73 // Determine the type of request this request is
76 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
78 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
83 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
84 AFS_TRACE_LEVEL_ERROR,
85 "AFSQueryFileInfo Attempted access (%p) when pFcb == NULL\n",
88 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
91 lLength = (LONG)pIrpSp->Parameters.QueryFile.Length;
92 stFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
93 pBuffer = Irp->AssociatedIrp.SystemBuffer;
95 if ( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
98 RtlZeroMemory( &stAuthGroup,
101 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
102 (ULONGLONG)PsGetCurrentThreadId(),
105 ntStatus = AFSVerifyEntry( &stAuthGroup,
108 if ( NT_SUCCESS( ntStatus))
111 ClearFlag( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
116 ntStatus = STATUS_SUCCESS;
121 // Grab the main shared right off the bat
124 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
125 AFS_TRACE_LEVEL_VERBOSE,
126 "AFSQueryFileInfo Acquiring Fcb lock %p SHARED %08lX\n",
127 &pFcb->NPFcb->Resource,
128 PsGetCurrentThread());
130 AFSAcquireShared( &pFcb->NPFcb->Resource,
136 // Don't allow requests against IOCtl nodes
139 if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
142 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
143 AFS_TRACE_LEVEL_VERBOSE,
144 "AFSQueryFileInfo Processing request against SpecialShare Fcb\n");
146 ntStatus = AFSProcessShareQueryInfo( Irp,
150 try_return( ntStatus);
152 else if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
154 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
155 AFS_TRACE_LEVEL_VERBOSE,
156 "AFSQueryFileInfo request against PIOCtl Fcb\n");
158 ntStatus = AFSProcessPIOCtlQueryInfo( Irp,
163 try_return( ntStatus);
166 else if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
168 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
169 AFS_TRACE_LEVEL_VERBOSE,
170 "AFSQueryFileInfo request against Invalid Fcb\n");
172 try_return( ntStatus = STATUS_ACCESS_DENIED);
176 // Process the request
179 switch( stFileInformationClass)
182 case FileAllInformation:
185 PFILE_ALL_INFORMATION pAllInfo;
188 // For the all information class we'll typecast a local
189 // pointer to the output buffer and then call the
190 // individual routines to fill in the buffer.
193 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
195 ntStatus = AFSQueryBasicInfo( Irp,
197 &pAllInfo->BasicInformation,
200 if( !NT_SUCCESS( ntStatus))
203 try_return( ntStatus);
206 ntStatus = AFSQueryStandardInfo( Irp,
208 &pAllInfo->StandardInformation,
211 if( !NT_SUCCESS( ntStatus))
214 try_return( ntStatus);
217 ntStatus = AFSQueryInternalInfo( Irp,
219 &pAllInfo->InternalInformation,
222 if( !NT_SUCCESS( ntStatus))
225 try_return( ntStatus);
228 ntStatus = AFSQueryEaInfo( Irp,
230 &pAllInfo->EaInformation,
233 if( !NT_SUCCESS( ntStatus))
236 try_return( ntStatus);
239 ntStatus = AFSQueryAccess( Irp,
241 &pAllInfo->AccessInformation,
244 if( !NT_SUCCESS( ntStatus))
247 try_return( ntStatus);
250 ntStatus = AFSQueryPositionInfo( Irp,
252 &pAllInfo->PositionInformation,
255 if( !NT_SUCCESS( ntStatus))
258 try_return( ntStatus);
261 ntStatus = AFSQueryMode( Irp,
263 &pAllInfo->ModeInformation,
266 if( !NT_SUCCESS( ntStatus))
269 try_return( ntStatus);
272 ntStatus = AFSQueryAlignment( Irp,
274 &pAllInfo->AlignmentInformation,
277 if( !NT_SUCCESS( ntStatus))
280 try_return( ntStatus);
283 ntStatus = AFSQueryNameInfo( Irp,
285 &pAllInfo->NameInformation,
288 if( !NT_SUCCESS( ntStatus))
291 try_return( ntStatus);
297 case FileBasicInformation:
300 ntStatus = AFSQueryBasicInfo( Irp,
302 (PFILE_BASIC_INFORMATION)pBuffer,
308 case FileStandardInformation:
311 ntStatus = AFSQueryStandardInfo( Irp,
313 (PFILE_STANDARD_INFORMATION)pBuffer,
319 case FileInternalInformation:
322 ntStatus = AFSQueryInternalInfo( Irp,
324 (PFILE_INTERNAL_INFORMATION)pBuffer,
330 case FileEaInformation:
333 ntStatus = AFSQueryEaInfo( Irp,
335 (PFILE_EA_INFORMATION)pBuffer,
341 case FilePositionInformation:
344 ntStatus = AFSQueryPositionInfo( Irp,
346 (PFILE_POSITION_INFORMATION)pBuffer,
352 case FileNormalizedNameInformation:
353 case FileNameInformation:
356 ntStatus = AFSQueryNameInfo( Irp,
358 (PFILE_NAME_INFORMATION)pBuffer,
364 case FileAlternateNameInformation:
367 ntStatus = AFSQueryShortNameInfo( Irp,
369 (PFILE_NAME_INFORMATION)pBuffer,
375 case FileNetworkOpenInformation:
378 ntStatus = AFSQueryNetworkInfo( Irp,
380 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
386 case FileStreamInformation:
389 ntStatus = AFSQueryStreamInfo( Irp,
391 (FILE_STREAM_INFORMATION *)pBuffer,
398 case FileAttributeTagInformation:
401 ntStatus = AFSQueryAttribTagInfo( Irp,
403 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
409 case FileRemoteProtocolInformation:
412 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
414 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
420 case FileNetworkPhysicalNameInformation:
423 ntStatus = AFSQueryPhysicalNameInfo( Irp,
425 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
433 ntStatus = STATUS_INVALID_PARAMETER;
440 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
445 AFSReleaseResource( &pFcb->NPFcb->Resource);
448 if( !NT_SUCCESS( ntStatus) &&
449 ntStatus != STATUS_INVALID_PARAMETER &&
450 ntStatus != STATUS_BUFFER_OVERFLOW)
454 pCcb->DirectoryCB != NULL)
457 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
458 AFS_TRACE_LEVEL_ERROR,
459 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
460 &pCcb->DirectoryCB->NameInformation.FileName,
461 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
462 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
463 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
464 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
469 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
474 "EXCEPTION - AFSQueryFileInfo\n");
476 AFSDumpTraceFilesFnc();
478 ntStatus = STATUS_UNSUCCESSFUL;
483 AFSReleaseResource( &pFcb->NPFcb->Resource);
487 AFSCompleteRequest( Irp,
494 // Function: AFSSetFileInfo
498 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
502 // A status is returned for the function
506 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
510 UNREFERENCED_PARAMETER(LibDeviceObject);
511 NTSTATUS ntStatus = STATUS_SUCCESS;
512 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
515 FILE_INFORMATION_CLASS FileInformationClass;
516 BOOLEAN bCanQueueRequest = FALSE;
517 PFILE_OBJECT pFileObject = NULL;
518 BOOLEAN bReleaseMain = FALSE;
519 BOOLEAN bUpdateFileInfo = FALSE;
520 AFSFileID stParentFileId;
525 pFileObject = pIrpSp->FileObject;
527 pFcb = (AFSFcb *)pFileObject->FsContext;
528 pCcb = (AFSCcb *)pFileObject->FsContext2;
533 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
534 AFS_TRACE_LEVEL_ERROR,
535 "AFSSetFileInfo Attempted access (%p) when pFcb == NULL\n",
538 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
541 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
542 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
548 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
549 AFS_TRACE_LEVEL_VERBOSE,
550 "AFSSetFileInfo Acquiring Fcb lock %p EXCL %08lX\n",
551 &pFcb->NPFcb->Resource,
552 PsGetCurrentThread());
554 AFSAcquireExcl( &pFcb->NPFcb->Resource,
560 // Don't allow requests against IOCtl nodes
563 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
566 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
567 AFS_TRACE_LEVEL_ERROR,
568 "AFSSetFileInfo Failing request against PIOCtl Fcb\n");
570 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
572 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
575 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
576 AFS_TRACE_LEVEL_VERBOSE,
577 "AFSSetFileInfo Processing request against SpecialShare Fcb\n");
579 ntStatus = AFSProcessShareSetInfo( Irp,
583 try_return( ntStatus);
586 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
589 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
590 AFS_TRACE_LEVEL_ERROR,
591 "AFSSetFileInfo Request failed due to read only volume\n",
594 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
597 if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB &&
598 FileInformationClass != FileDispositionInformation)
600 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
601 AFS_TRACE_LEVEL_VERBOSE,
602 "AFSSetFileInfo request against Invalid Fcb\n");
604 try_return( ntStatus = STATUS_ACCESS_DENIED);
608 // Ensure rename operations are synchronous
611 if( FileInformationClass == FileRenameInformation)
614 bCanQueueRequest = FALSE;
618 // Store away the parent fid
621 RtlZeroMemory( &stParentFileId,
624 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
626 stParentFileId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
630 // Process the request
633 switch( FileInformationClass)
636 case FileBasicInformation:
639 bUpdateFileInfo = TRUE;
641 ntStatus = AFSSetBasicInfo( Irp,
647 case FileDispositionInformation:
650 ntStatus = AFSSetDispositionInfo( Irp,
656 case FileRenameInformation:
659 ntStatus = AFSSetRenameInfo( Irp);
664 case FilePositionInformation:
667 ntStatus = AFSSetPositionInfo( Irp,
673 case FileLinkInformation:
676 ntStatus = AFSSetFileLinkInfo( Irp);
681 case FileAllocationInformation:
684 ntStatus = AFSSetAllocationInfo( Irp,
690 case FileEndOfFileInformation:
693 ntStatus = AFSSetEndOfFileInfo( Irp,
701 ntStatus = STATUS_INVALID_PARAMETER;
711 AFSReleaseResource( &pFcb->NPFcb->Resource);
714 if( NT_SUCCESS( ntStatus) &&
718 ntStatus = AFSUpdateFileInformation( &stParentFileId,
719 pFcb->ObjectInformation,
722 if( !NT_SUCCESS( ntStatus))
725 AFSAcquireExcl( &pFcb->NPFcb->Resource,
729 // Unwind the update and fail the request
732 AFSUnwindFileInfo( pFcb,
735 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
736 AFS_TRACE_LEVEL_ERROR,
737 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
738 &pCcb->DirectoryCB->NameInformation.FileName,
739 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
740 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
741 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
742 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
745 AFSReleaseResource( &pFcb->NPFcb->Resource);
749 if( !NT_SUCCESS( ntStatus))
753 pCcb->DirectoryCB != NULL)
756 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
757 AFS_TRACE_LEVEL_ERROR,
758 "AFSSetFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
759 &pCcb->DirectoryCB->NameInformation.FileName,
760 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
761 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
762 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
763 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
768 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
773 "EXCEPTION - AFSSetFileInfo\n");
775 AFSDumpTraceFilesFnc();
777 ntStatus = STATUS_UNSUCCESSFUL;
782 AFSReleaseResource( &pFcb->NPFcb->Resource);
786 AFSCompleteRequest( Irp,
793 // Function: AFSQueryBasicInfo
797 // This function is the handler for the query basic information request
801 // A status is returned for the function
805 AFSQueryBasicInfo( IN PIRP Irp,
806 IN AFSDirectoryCB *DirectoryCB,
807 IN OUT PFILE_BASIC_INFORMATION Buffer,
810 NTSTATUS ntStatus = STATUS_SUCCESS;
811 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
812 ULONG ulFileAttribs = 0;
815 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
816 AFSFileInfoCB stFileInfo;
817 AFSDirectoryCB *pParentDirectoryCB = NULL;
818 UNICODE_STRING uniParentPath;
820 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
823 RtlZeroMemory( Buffer,
826 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
828 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
829 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
831 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
834 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
836 AFSRetrieveParentPath( &pCcb->FullFileName,
839 RtlZeroMemory( &stFileInfo,
840 sizeof( AFSFileInfoCB));
843 // Can't hold the Fcb while evaluating the path, leads to lock inversion
846 AFSReleaseResource( &pFcb->NPFcb->Resource);
848 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
856 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
859 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
864 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
867 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
870 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
874 AFSAcquireShared( &pFcb->NPFcb->Resource,
879 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
880 AFS_TRACE_LEVEL_VERBOSE_2,
881 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
882 &pCcb->DirectoryCB->NameInformation.FileName,
883 pCcb->DirectoryCB->ObjectInformation->FileType,
884 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
887 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
888 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
889 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
890 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
891 Buffer->FileAttributes = ulFileAttribs;
893 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
894 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
897 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
899 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
903 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
907 *Length -= sizeof( FILE_BASIC_INFORMATION);
912 ntStatus = STATUS_BUFFER_TOO_SMALL;
919 AFSQueryStandardInfo( IN PIRP Irp,
920 IN AFSDirectoryCB *DirectoryCB,
921 IN OUT PFILE_STANDARD_INFORMATION Buffer,
925 NTSTATUS ntStatus = STATUS_SUCCESS;
928 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
929 AFSFileInfoCB stFileInfo;
930 AFSDirectoryCB *pParentDirectoryCB = NULL;
931 UNICODE_STRING uniParentPath;
932 ULONG ulFileAttribs = 0;
934 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
937 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
938 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
940 RtlZeroMemory( Buffer,
943 Buffer->NumberOfLinks = 1;
944 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
946 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
948 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
950 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
952 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
955 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
957 AFSRetrieveParentPath( &pCcb->FullFileName,
960 RtlZeroMemory( &stFileInfo,
961 sizeof( AFSFileInfoCB));
964 // Can't hold the Fcb while evaluating the path, leads to lock inversion
967 AFSReleaseResource( &pFcb->NPFcb->Resource);
969 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
977 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
980 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
985 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
988 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
991 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
995 AFSAcquireShared( &pFcb->NPFcb->Resource,
999 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1000 AFS_TRACE_LEVEL_VERBOSE_2,
1001 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1002 &pCcb->DirectoryCB->NameInformation.FileName,
1003 pCcb->DirectoryCB->ObjectInformation->FileType,
1004 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1007 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
1009 *Length -= sizeof( FILE_STANDARD_INFORMATION);
1014 ntStatus = STATUS_BUFFER_TOO_SMALL;
1021 AFSQueryInternalInfo( IN PIRP Irp,
1023 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
1024 IN OUT PLONG Length)
1027 UNREFERENCED_PARAMETER(Irp);
1028 NTSTATUS ntStatus = STATUS_SUCCESS;
1030 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
1033 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Volume;
1035 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Vnode;
1037 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
1042 ntStatus = STATUS_BUFFER_TOO_SMALL;
1049 AFSQueryEaInfo( IN PIRP Irp,
1050 IN AFSDirectoryCB *DirectoryCB,
1051 IN OUT PFILE_EA_INFORMATION Buffer,
1052 IN OUT PLONG Length)
1055 UNREFERENCED_PARAMETER(Irp);
1056 UNREFERENCED_PARAMETER(DirectoryCB);
1057 NTSTATUS ntStatus = STATUS_SUCCESS;
1059 RtlZeroMemory( Buffer,
1062 if( *Length >= sizeof( FILE_EA_INFORMATION))
1067 *Length -= sizeof( FILE_EA_INFORMATION);
1072 ntStatus = STATUS_BUFFER_TOO_SMALL;
1079 AFSQueryPositionInfo( IN PIRP Irp,
1081 IN OUT PFILE_POSITION_INFORMATION Buffer,
1082 IN OUT PLONG Length)
1085 UNREFERENCED_PARAMETER(Fcb);
1086 NTSTATUS ntStatus = STATUS_SUCCESS;
1087 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1089 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1092 RtlZeroMemory( Buffer,
1095 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1097 *Length -= sizeof( FILE_POSITION_INFORMATION);
1102 ntStatus = STATUS_BUFFER_TOO_SMALL;
1109 AFSQueryAccess( IN PIRP Irp,
1111 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1112 IN OUT PLONG Length)
1115 UNREFERENCED_PARAMETER(Irp);
1116 UNREFERENCED_PARAMETER(Fcb);
1117 NTSTATUS ntStatus = STATUS_SUCCESS;
1119 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1122 RtlZeroMemory( Buffer,
1125 Buffer->AccessFlags = 0;
1127 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1132 ntStatus = STATUS_BUFFER_TOO_SMALL;
1139 AFSQueryMode( IN PIRP Irp,
1141 IN OUT PFILE_MODE_INFORMATION Buffer,
1142 IN OUT PLONG Length)
1145 UNREFERENCED_PARAMETER(Irp);
1146 UNREFERENCED_PARAMETER(Fcb);
1147 NTSTATUS ntStatus = STATUS_SUCCESS;
1149 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1152 RtlZeroMemory( Buffer,
1157 *Length -= sizeof( FILE_MODE_INFORMATION);
1162 ntStatus = STATUS_BUFFER_TOO_SMALL;
1169 AFSQueryAlignment( IN PIRP Irp,
1171 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1172 IN OUT PLONG Length)
1175 UNREFERENCED_PARAMETER(Irp);
1176 UNREFERENCED_PARAMETER(Fcb);
1177 NTSTATUS ntStatus = STATUS_SUCCESS;
1179 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1182 RtlZeroMemory( Buffer,
1185 Buffer->AlignmentRequirement = 1;
1187 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1192 ntStatus = STATUS_BUFFER_TOO_SMALL;
1199 AFSQueryNameInfo( IN PIRP Irp,
1200 IN AFSDirectoryCB *DirectoryCB,
1201 IN OUT PFILE_NAME_INFORMATION Buffer,
1202 IN OUT PLONG Length)
1205 UNREFERENCED_PARAMETER(DirectoryCB);
1206 NTSTATUS ntStatus = STATUS_SUCCESS;
1207 ULONG ulCopyLength = 0;
1208 ULONG cchCopied = 0;
1209 AFSFcb *pFcb = NULL;
1210 AFSCcb *pCcb = NULL;
1211 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1212 BOOLEAN bAddLeadingSlash = FALSE;
1213 BOOLEAN bAddTrailingSlash = FALSE;
1214 USHORT usFullNameLength = 0;
1216 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1218 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1220 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1223 RtlZeroMemory( Buffer,
1226 if( pCcb->FullFileName.Length == 0 ||
1227 pCcb->FullFileName.Buffer[ 0] != L'\\')
1229 bAddLeadingSlash = TRUE;
1232 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1233 pCcb->FullFileName.Length > 0 &&
1234 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1236 bAddTrailingSlash = TRUE;
1239 usFullNameLength = sizeof( WCHAR) +
1240 AFSServerName.Length +
1241 pCcb->FullFileName.Length;
1243 if( bAddLeadingSlash)
1245 usFullNameLength += sizeof( WCHAR);
1248 if( bAddTrailingSlash)
1250 usFullNameLength += sizeof( WCHAR);
1253 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1256 ulCopyLength = (LONG)usFullNameLength;
1261 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1263 ntStatus = STATUS_BUFFER_OVERFLOW;
1266 Buffer->FileNameLength = (ULONG)usFullNameLength;
1268 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1270 if( ulCopyLength > 0)
1273 Buffer->FileName[ 0] = L'\\';
1274 ulCopyLength -= sizeof( WCHAR);
1276 *Length -= sizeof( WCHAR);
1279 if( ulCopyLength >= AFSServerName.Length)
1282 RtlCopyMemory( &Buffer->FileName[ 1],
1283 AFSServerName.Buffer,
1284 AFSServerName.Length);
1286 ulCopyLength -= AFSServerName.Length;
1287 *Length -= AFSServerName.Length;
1288 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1290 if ( ulCopyLength > 0 &&
1294 Buffer->FileName[ cchCopied] = L'\\';
1296 ulCopyLength -= sizeof( WCHAR);
1297 *Length -= sizeof( WCHAR);
1301 if( ulCopyLength >= pCcb->FullFileName.Length)
1304 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1305 pCcb->FullFileName.Buffer,
1306 pCcb->FullFileName.Length);
1308 ulCopyLength -= pCcb->FullFileName.Length;
1309 *Length -= pCcb->FullFileName.Length;
1310 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1312 if( ulCopyLength > 0 &&
1315 Buffer->FileName[ cchCopied] = L'\\';
1317 *Length -= sizeof( WCHAR);
1323 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1324 pCcb->FullFileName.Buffer,
1327 *Length -= ulCopyLength;
1335 ntStatus = STATUS_BUFFER_TOO_SMALL;
1342 AFSQueryShortNameInfo( IN PIRP Irp,
1343 IN AFSDirectoryCB *DirectoryCB,
1344 IN OUT PFILE_NAME_INFORMATION Buffer,
1345 IN OUT PLONG Length)
1348 UNREFERENCED_PARAMETER(Irp);
1349 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1350 ULONG ulCopyLength = 0;
1352 RtlZeroMemory( Buffer,
1355 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1359 // The short name IS the long name
1362 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1365 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1368 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1370 ntStatus = STATUS_SUCCESS;
1375 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1377 ntStatus = STATUS_BUFFER_OVERFLOW;
1380 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1382 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1384 if( ulCopyLength > 0)
1387 RtlCopyMemory( Buffer->FileName,
1388 DirectoryCB->NameInformation.FileName.Buffer,
1391 *Length -= ulCopyLength;
1398 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1401 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1404 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1406 ntStatus = STATUS_SUCCESS;
1411 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1413 ntStatus = STATUS_BUFFER_OVERFLOW;
1416 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1418 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1420 if( ulCopyLength > 0)
1423 RtlCopyMemory( Buffer->FileName,
1424 DirectoryCB->NameInformation.ShortName,
1425 Buffer->FileNameLength);
1427 *Length -= ulCopyLength;
1436 AFSQueryNetworkInfo( IN PIRP Irp,
1437 IN AFSDirectoryCB *DirectoryCB,
1438 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1439 IN OUT PLONG Length)
1442 NTSTATUS ntStatus = STATUS_SUCCESS;
1443 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1444 AFSFcb *pFcb = NULL;
1445 AFSCcb *pCcb = NULL;
1446 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1447 AFSFileInfoCB stFileInfo;
1448 AFSDirectoryCB *pParentDirectoryCB = NULL;
1449 UNICODE_STRING uniParentPath;
1450 ULONG ulFileAttribs = 0;
1452 RtlZeroMemory( Buffer,
1455 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1458 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1460 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1461 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1463 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1466 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1468 AFSRetrieveParentPath( &pCcb->FullFileName,
1471 RtlZeroMemory( &stFileInfo,
1472 sizeof( AFSFileInfoCB));
1475 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1478 AFSReleaseResource( &pFcb->NPFcb->Resource);
1480 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1488 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1491 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1496 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1499 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1502 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1506 AFSAcquireShared( &pFcb->NPFcb->Resource,
1510 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1511 AFS_TRACE_LEVEL_VERBOSE_2,
1512 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1513 &pCcb->DirectoryCB->NameInformation.FileName,
1514 pCcb->DirectoryCB->ObjectInformation->FileType,
1515 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1518 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1519 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1520 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1521 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1523 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1524 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1526 Buffer->FileAttributes = ulFileAttribs;
1528 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1529 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1532 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1535 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1540 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1544 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1549 ntStatus = STATUS_BUFFER_TOO_SMALL;
1556 AFSQueryStreamInfo( IN PIRP Irp,
1557 IN AFSDirectoryCB *DirectoryCB,
1558 IN OUT FILE_STREAM_INFORMATION *Buffer,
1559 IN OUT PLONG Length)
1562 UNREFERENCED_PARAMETER(Irp);
1563 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1564 ULONG ulCopyLength = 0;
1566 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1569 RtlZeroMemory( Buffer,
1572 Buffer->NextEntryOffset = 0;
1575 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1578 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1583 ntStatus = STATUS_SUCCESS;
1588 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1590 ntStatus = STATUS_BUFFER_OVERFLOW;
1593 Buffer->StreamNameLength = 14; // ::$DATA
1595 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1597 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1599 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1601 if( ulCopyLength > 0)
1604 RtlCopyMemory( Buffer->StreamName,
1608 *Length -= ulCopyLength;
1614 Buffer->StreamNameLength = 0; // No stream for a directory
1616 // The response size is zero
1618 ntStatus = STATUS_SUCCESS;
1626 AFSQueryAttribTagInfo( IN PIRP Irp,
1627 IN AFSDirectoryCB *DirectoryCB,
1628 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1629 IN OUT PLONG Length)
1632 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1633 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1634 AFSFcb *pFcb = NULL;
1635 AFSCcb *pCcb = NULL;
1636 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1637 AFSFileInfoCB stFileInfo;
1638 AFSDirectoryCB *pParentDirectoryCB = NULL;
1639 UNICODE_STRING uniParentPath;
1640 ULONG ulFileAttribs = 0;
1642 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1645 RtlZeroMemory( Buffer,
1648 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1650 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1651 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1653 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1656 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1658 AFSRetrieveParentPath( &pCcb->FullFileName,
1661 RtlZeroMemory( &stFileInfo,
1662 sizeof( AFSFileInfoCB));
1665 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1668 AFSReleaseResource( &pFcb->NPFcb->Resource);
1670 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1678 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1681 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1686 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1689 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1692 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1696 AFSAcquireShared( &pFcb->NPFcb->Resource,
1700 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1701 AFS_TRACE_LEVEL_VERBOSE_2,
1702 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1703 &pCcb->DirectoryCB->NameInformation.FileName,
1704 pCcb->DirectoryCB->ObjectInformation->FileType,
1705 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1708 Buffer->FileAttributes = ulFileAttribs;
1710 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1711 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1714 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1717 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1722 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1726 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1728 Buffer->ReparseTag = IO_REPARSE_TAG_SURROGATE|IO_REPARSE_TAG_OPENAFS_DFS;
1731 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1733 ntStatus = STATUS_SUCCESS;
1740 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1741 IN AFSDirectoryCB *DirectoryCB,
1742 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1743 IN OUT PLONG Length)
1746 UNREFERENCED_PARAMETER(Irp);
1747 UNREFERENCED_PARAMETER(DirectoryCB);
1748 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1750 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1753 RtlZeroMemory( Buffer,
1756 Buffer->StructureVersion = 1;
1758 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1760 Buffer->Protocol = WNNC_NET_OPENAFS;
1762 Buffer->ProtocolMajorVersion = 3;
1764 Buffer->ProtocolMinorVersion = 0;
1766 Buffer->ProtocolRevision = 0;
1768 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1770 ntStatus = STATUS_SUCCESS;
1777 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1778 IN AFSDirectoryCB *DirectoryCB,
1779 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1780 IN OUT PLONG Length)
1783 UNREFERENCED_PARAMETER(DirectoryCB);
1784 NTSTATUS ntStatus = STATUS_SUCCESS;
1785 ULONG ulCopyLength = 0;
1786 ULONG cchCopied = 0;
1787 AFSFcb *pFcb = NULL;
1788 AFSCcb *pCcb = NULL;
1789 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1790 BOOLEAN bAddLeadingSlash = FALSE;
1791 USHORT usFullNameLength = 0;
1793 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1795 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1797 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1800 RtlZeroMemory( Buffer,
1803 if( pCcb->FullFileName.Length == 0 ||
1804 pCcb->FullFileName.Buffer[ 0] != L'\\')
1806 bAddLeadingSlash = TRUE;
1809 usFullNameLength = pCcb->FullFileName.Length;
1811 if( bAddLeadingSlash)
1813 usFullNameLength += sizeof( WCHAR);
1816 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1818 ulCopyLength = (LONG)usFullNameLength;
1823 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1825 ntStatus = STATUS_BUFFER_OVERFLOW;
1828 Buffer->FileNameLength = (ULONG)usFullNameLength;
1830 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1832 if( ulCopyLength > 0)
1835 if( bAddLeadingSlash)
1838 Buffer->FileName[ cchCopied] = L'\\';
1840 ulCopyLength -= sizeof( WCHAR);
1841 *Length -= sizeof( WCHAR);
1845 if( ulCopyLength >= pCcb->FullFileName.Length)
1848 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1849 pCcb->FullFileName.Buffer,
1850 pCcb->FullFileName.Length);
1852 ulCopyLength -= pCcb->FullFileName.Length;
1853 *Length -= pCcb->FullFileName.Length;
1854 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1859 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1860 pCcb->FullFileName.Buffer,
1863 *Length -= ulCopyLength;
1870 ntStatus = STATUS_BUFFER_TOO_SMALL;
1877 AFSSetBasicInfo( IN PIRP Irp,
1878 IN AFSDirectoryCB *DirectoryCB)
1880 NTSTATUS ntStatus = STATUS_SUCCESS;
1881 PFILE_BASIC_INFORMATION pBuffer;
1882 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1883 ULONG ulNotifyFilter = 0;
1884 AFSCcb *pCcb = NULL;
1889 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1891 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1893 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1895 if( pBuffer->FileAttributes != (ULONGLONG)0)
1898 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1899 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1902 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1905 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1908 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1911 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1913 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1915 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1917 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1920 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1922 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1923 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1926 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1928 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1930 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1932 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1935 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1937 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1938 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1941 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1943 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1945 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1947 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1950 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1952 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1953 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1956 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1958 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1960 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1962 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1965 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1967 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1968 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1971 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1973 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
1975 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1977 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1980 if( ulNotifyFilter > 0)
1983 if( DirectoryCB->ObjectInformation->ParentObjectInformation != NULL)
1986 AFSFsRtlNotifyFullReportChange( DirectoryCB->ObjectInformation->ParentObjectInformation,
1988 (ULONG)ulNotifyFilter,
1989 (ULONG)FILE_ACTION_MODIFIED);
2002 AFSSetDispositionInfo( IN PIRP Irp,
2003 IN AFSDirectoryCB *DirectoryCB)
2005 NTSTATUS ntStatus = STATUS_SUCCESS;
2006 PFILE_DISPOSITION_INFORMATION pBuffer;
2007 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2008 AFSFcb *pFcb = NULL;
2009 AFSCcb *pCcb = NULL;
2014 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2016 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2018 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2021 // Can't delete the root
2024 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2027 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2028 AFS_TRACE_LEVEL_ERROR,
2029 "AFSSetDispositionInfo Attempt to delete root entry\n");
2031 try_return( ntStatus = STATUS_CANNOT_DELETE);
2035 // If the file is read only then do not allow the delete
2038 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
2041 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2042 AFS_TRACE_LEVEL_ERROR,
2043 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
2044 &DirectoryCB->NameInformation.FileName);
2046 try_return( ntStatus = STATUS_CANNOT_DELETE);
2049 if( pBuffer->DeleteFile)
2053 // Check if the caller can delete the file
2056 ntStatus = AFSNotifyDelete( DirectoryCB,
2060 if( !NT_SUCCESS( ntStatus))
2063 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2064 AFS_TRACE_LEVEL_ERROR,
2065 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
2066 &DirectoryCB->NameInformation.FileName,
2069 try_return( ntStatus);
2072 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2076 // Reduce the Link count in the object information block
2077 // to correspond with the deletion of the directory entry.
2080 pFcb->ObjectInformation->Links--;
2083 // Check if this is a directory that there are not currently other opens
2086 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2089 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2090 AFS_TRACE_LEVEL_ERROR,
2091 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
2092 &DirectoryCB->NameInformation.FileName,
2093 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount);
2095 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2098 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2101 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2102 AFS_TRACE_LEVEL_ERROR,
2103 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2104 &DirectoryCB->NameInformation.FileName);
2106 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2109 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2110 AFS_TRACE_LEVEL_VERBOSE,
2111 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2113 &DirectoryCB->NameInformation.FileName);
2115 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2117 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2121 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2122 AFS_TRACE_LEVEL_VERBOSE,
2123 "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
2124 &pFcb->NPFcb->SectionObjectResource,
2125 PsGetCurrentThread());
2127 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
2131 // Attempt to flush any outstanding data
2134 bMmFlushed = MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2141 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2142 // deadlock with Trend Micro's Enterprise anti-virus product
2143 // which attempts to open the file which is being deleted.
2146 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2147 AFS_TRACE_LEVEL_VERBOSE,
2148 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2150 &DirectoryCB->NameInformation.FileName);
2152 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2155 // Purge the cache as well
2158 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2161 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2167 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2172 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2173 AFS_TRACE_LEVEL_VERBOSE,
2174 "AFSSetDispositionInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
2175 &pFcb->NPFcb->SectionObjectResource,
2176 PsGetCurrentThread());
2178 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
2183 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2184 AFS_TRACE_LEVEL_ERROR,
2185 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2186 &DirectoryCB->NameInformation.FileName);
2188 try_return( ntStatus = STATUS_CANNOT_DELETE);
2195 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2199 // OK, should be good to go, set the flag in the file object
2202 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2213 AFSSetFileLinkInfo( IN PIRP Irp)
2216 NTSTATUS ntStatus = STATUS_SUCCESS;
2217 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2218 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2219 PFILE_LINK_INFORMATION pFileLinkInfo = NULL;
2220 PFILE_OBJECT pSrcFileObj = NULL;
2221 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2222 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL;
2223 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2224 AFSObjectInfoCB *pSrcObject = NULL;
2225 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2226 UNICODE_STRING uniSourceName, uniTargetName;
2227 UNICODE_STRING uniFullTargetName, uniTargetParentName;
2228 BOOLEAN bCommonParent = FALSE;
2229 AFSDirectoryCB *pTargetDirEntry = NULL;
2230 AFSDirectoryCB *pNewTargetDirEntry = NULL;
2232 BOOLEAN bTargetEntryExists = FALSE;
2234 BOOLEAN bReleaseTargetDirLock = FALSE;
2235 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2240 pSrcFileObj = pIrpSp->FileObject;
2242 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2243 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2245 pSrcObject = pSrcFcb->ObjectInformation;
2246 pSrcParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2248 pFileLinkInfo = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2251 // Perform some basic checks to ensure FS integrity
2254 if( pSrcFcb->Header.NodeTypeCode != AFS_FILE_FCB)
2257 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2258 AFS_TRACE_LEVEL_ERROR,
2259 "AFSSetFileLinkInfo Attempt to non-file (INVALID_PARAMETER)\n");
2261 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2264 if( pTargetFileObj == NULL)
2267 if ( pFileLinkInfo->RootDirectory)
2271 // The target directory is provided by HANDLE
2272 // RootDirectory is only set when the target directory is not the same
2273 // as the source directory.
2275 // AFS only supports hard links within a single directory.
2277 // The IOManager should translate any Handle to a FileObject for us.
2278 // However, the failure to receive a FileObject is treated as a fatal
2282 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2283 AFS_TRACE_LEVEL_ERROR,
2284 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory by handle INVALID_PARAMETER\n",
2285 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2287 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2292 uniFullTargetName.Length = (USHORT)pFileLinkInfo->FileNameLength;
2294 uniFullTargetName.Buffer = (PWSTR)&pFileLinkInfo->FileName;
2296 AFSRetrieveFinalComponent( &uniFullTargetName,
2299 AFSRetrieveParentPath( &uniFullTargetName,
2300 &uniTargetParentName);
2302 if ( uniTargetParentName.Length == 0)
2306 // This is a simple rename. Here the target directory is the same as the source parent directory
2307 // and the name is retrieved from the system buffer information
2310 pTargetParentObject = pSrcParentObject;
2315 // uniTargetParentName contains the directory the renamed object
2316 // will be moved to. Must obtain the TargetParentObject.
2319 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2320 AFS_TRACE_LEVEL_ERROR,
2321 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory %wZ (NOT_SAME_DEVICE)\n",
2322 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2323 &uniFullTargetName);
2325 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2329 pTargetDcb = pTargetParentObject->Fcb;
2335 // So here we have the target directory taken from the targetfile object
2338 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2340 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2342 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2345 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2346 // it is only the target component of the rename operation
2349 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2353 // The quick check to see if they are self linking.
2354 // Do the names match? Only do this where the parent directories are
2358 if( pTargetParentObject == pSrcParentObject)
2361 if( FsRtlAreNamesEqual( &uniTargetName,
2366 try_return( ntStatus = STATUS_SUCCESS);
2369 bCommonParent = TRUE;
2375 // We do not allow cross-volume hard links
2378 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2381 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2382 AFS_TRACE_LEVEL_ERROR,
2383 "AFSSetFileLinkInfo Attempt to link to different volume %wZ\n",
2384 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2386 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2390 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2393 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2396 bReleaseTargetDirLock = TRUE;
2398 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2402 if( pTargetDirEntry == NULL)
2406 // Missed so perform a case insensitive lookup
2409 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2412 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2417 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2418 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2423 // Try the short name
2425 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2431 // Increment our ref count on the dir entry
2434 if( pTargetDirEntry != NULL)
2437 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2439 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2441 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2442 AFS_TRACE_LEVEL_VERBOSE,
2443 "AFSSetFileLinkInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2444 &pTargetDirEntry->NameInformation.FileName,
2449 ASSERT( lCount >= 0);
2451 if( !pFileLinkInfo->ReplaceIfExists)
2454 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2455 AFS_TRACE_LEVEL_ERROR,
2456 "AFSSetFileLinkInfo Attempt to link with target collision %wZ Target %wZ\n",
2457 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2458 &pTargetDirEntry->NameInformation.FileName);
2460 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2463 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2464 AFS_TRACE_LEVEL_ERROR,
2465 "AFSSetFileLinkInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2466 &pTargetDirEntry->NameInformation.FileName,
2471 // Pull the directory entry from the parent
2474 AFSRemoveDirNodeFromParent( pTargetParentObject,
2478 bTargetEntryExists = TRUE;
2482 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2483 AFS_TRACE_LEVEL_VERBOSE,
2484 "AFSSetFileLinkInfo Target does NOT exist, normal linking\n");
2488 // OK, this is a simple rename. Issue the rename
2489 // request to the service.
2492 ntStatus = AFSNotifyHardLink( pSrcFcb->ObjectInformation,
2493 &pSrcCcb->AuthGroup,
2494 pSrcFcb->ObjectInformation->ParentObjectInformation,
2495 pTargetDcb->ObjectInformation,
2496 pSrcCcb->DirectoryCB,
2498 pFileLinkInfo->ReplaceIfExists,
2499 &pNewTargetDirEntry);
2501 if( ntStatus != STATUS_REPARSE &&
2502 !NT_SUCCESS( ntStatus))
2505 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2506 AFS_TRACE_LEVEL_ERROR,
2507 "AFSSetFileLinkInfo Failed link of %wZ to target %wZ Status %08lX\n",
2508 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2512 try_return( ntStatus);
2515 if ( ntStatus != STATUS_REPARSE)
2518 AFSInsertDirectoryNode( pTargetDcb->ObjectInformation,
2524 // Send notification for the target link file
2527 if( bTargetEntryExists || pNewTargetDirEntry)
2530 ulNotificationAction = FILE_ACTION_MODIFIED;
2535 ulNotificationAction = FILE_ACTION_ADDED;
2538 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
2540 (ULONG)ulNotifyFilter,
2541 (ULONG)ulNotificationAction);
2545 if( !NT_SUCCESS( ntStatus))
2548 if( bTargetEntryExists)
2551 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
2557 if( pTargetDirEntry != NULL)
2561 // Release DirOpenReferenceCount obtained above
2564 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
2566 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2567 AFS_TRACE_LEVEL_VERBOSE,
2568 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2569 &pTargetDirEntry->NameInformation.FileName,
2574 ASSERT( lCount >= 0);
2577 if( pNewTargetDirEntry != NULL)
2581 // Release DirOpenReferenceCount obtained from AFSNotifyHardLink
2584 lCount = InterlockedDecrement( &pNewTargetDirEntry->DirOpenReferenceCount);
2586 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2587 AFS_TRACE_LEVEL_VERBOSE,
2588 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2589 &pNewTargetDirEntry->NameInformation.FileName,
2594 ASSERT( lCount >= 0);
2597 if( bReleaseTargetDirLock)
2600 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2608 AFSSetRenameInfo( IN PIRP Irp)
2611 NTSTATUS ntStatus = STATUS_SUCCESS;
2612 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2613 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2614 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2615 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2616 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2617 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2618 PFILE_OBJECT pTargetParentFileObj = NULL;
2619 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2620 UNICODE_STRING uniTargetName, uniSourceName, uniTargetParentName;
2621 BOOLEAN bReplaceIfExists = FALSE;
2622 UNICODE_STRING uniShortName;
2623 AFSDirectoryCB *pTargetDirEntry = NULL;
2624 ULONG ulTargetCRC = 0;
2625 BOOLEAN bTargetEntryExists = FALSE;
2626 AFSObjectInfoCB *pSrcObject = NULL;
2627 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2629 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2630 UNICODE_STRING uniFullTargetName;
2631 BOOLEAN bCommonParent = FALSE;
2632 BOOLEAN bReleaseTargetDirLock = FALSE;
2633 BOOLEAN bReleaseSourceDirLock = FALSE;
2634 BOOLEAN bDereferenceTargetParentObject = FALSE;
2635 PERESOURCE pSourceDirLock = NULL;
2641 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2643 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2645 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2646 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2648 pSrcObject = pSrcFcb->ObjectInformation;
2649 pSrcParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2652 // Perform some basic checks to ensure FS integrity
2655 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2659 // Can't rename the root directory
2662 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2663 AFS_TRACE_LEVEL_ERROR,
2664 "AFSSetRenameInfo Attempt to rename root entry\n");
2666 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2669 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2673 // If there are any open children then fail the rename
2676 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2679 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2680 AFS_TRACE_LEVEL_ERROR,
2681 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2682 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2684 try_return( ntStatus = STATUS_ACCESS_DENIED);
2690 // Extract off the final component name from the Fcb
2693 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2694 uniSourceName.MaximumLength = uniSourceName.Length;
2696 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2699 // Resolve the target fileobject
2702 if( pTargetFileObj == NULL)
2705 if ( pRenameInfo->RootDirectory)
2708 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2709 AFS_TRACE_LEVEL_ERROR,
2710 "AFSSetRenameInfo Handle provided but no FileObject ntStatus INVALID_PARAMETER\n");
2712 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2717 uniFullTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2719 uniFullTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2721 AFSRetrieveFinalComponent( &uniFullTargetName,
2724 AFSRetrieveParentPath( &uniFullTargetName,
2725 &uniTargetParentName);
2727 if ( uniTargetParentName.Length == 0)
2731 // This is a simple rename. Here the target directory is the same as the source parent directory
2732 // and the name is retrieved from the system buffer information
2735 pTargetParentObject = pSrcParentObject;
2740 // uniTargetParentName contains the directory the renamed object
2741 // will be moved to. Must obtain the TargetParentObject.
2744 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2745 AFS_TRACE_LEVEL_ERROR,
2746 "AFSSetRenameInfo Attempt to move %wZ to %wZ -- not yet supported (NOT_SAME_DEVICE)\n",
2747 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2748 &uniFullTargetName);
2750 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2754 pTargetDcb = pTargetParentObject->Fcb;
2760 // So here we have the target directory taken from the targetfile object
2763 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2765 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2767 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2770 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2771 // it is only the target component of the rename operation
2774 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2778 // The quick check to see if they are not really performing a rename
2779 // Do the names match? Only do this where the parent directories are
2783 if( pTargetParentObject == pSrcParentObject)
2786 if( FsRtlAreNamesEqual( &uniTargetName,
2791 try_return( ntStatus = STATUS_SUCCESS);
2794 bCommonParent = TRUE;
2799 bCommonParent = FALSE;
2803 // We do not allow cross-volume renames to occur
2806 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2809 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2810 AFS_TRACE_LEVEL_ERROR,
2811 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2812 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2814 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2817 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2820 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2823 bReleaseTargetDirLock = TRUE;
2825 if( pTargetParentObject != pSrcParentObject)
2827 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2830 bReleaseSourceDirLock = TRUE;
2832 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2835 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2839 if( pTargetDirEntry == NULL)
2843 // Missed so perform a case insensitive lookup
2846 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2849 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2854 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2855 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2860 // Try the short name
2862 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2868 // Increment our ref count on the dir entry
2871 if( pTargetDirEntry != NULL)
2874 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2876 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2878 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2879 AFS_TRACE_LEVEL_VERBOSE,
2880 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2881 &pTargetDirEntry->NameInformation.FileName,
2886 ASSERT( lCount >= 0);
2888 if( !bReplaceIfExists)
2891 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2892 AFS_TRACE_LEVEL_ERROR,
2893 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2894 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2895 &pTargetDirEntry->NameInformation.FileName);
2897 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2900 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2901 AFS_TRACE_LEVEL_ERROR,
2902 "AFSSetRenameInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2903 &pTargetDirEntry->NameInformation.FileName,
2908 // Pull the directory entry from the parent
2911 AFSRemoveDirNodeFromParent( pTargetParentObject,
2915 bTargetEntryExists = TRUE;
2919 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2920 AFS_TRACE_LEVEL_VERBOSE,
2921 "AFSSetRenameInfo Target does NOT exist, normal rename\n");
2925 // We need to remove the DirEntry from the parent node, update the index
2926 // and reinsert it into the parent tree. Note that for entries with the
2927 // same parent we do not pull the node from the enumeration list
2930 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2931 pSrcCcb->DirectoryCB,
2935 // OK, this is a simple rename. Issue the rename
2936 // request to the service.
2939 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2940 &pSrcCcb->AuthGroup,
2941 pSrcFcb->ObjectInformation->ParentObjectInformation,
2942 pTargetDcb->ObjectInformation,
2943 pSrcCcb->DirectoryCB,
2947 if( !NT_SUCCESS( ntStatus))
2951 // Attempt to re-insert the directory entry
2954 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2955 pSrcCcb->DirectoryCB,
2958 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2959 AFS_TRACE_LEVEL_ERROR,
2960 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2961 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2965 try_return( ntStatus);
2969 // Set the notification up for the source file
2972 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2973 !bTargetEntryExists)
2976 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2981 ulNotificationAction = FILE_ACTION_REMOVED;
2984 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2987 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2992 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2995 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2997 (ULONG)ulNotifyFilter,
2998 (ULONG)ulNotificationAction);
3001 // Update the name in the dir entry.
3004 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
3007 if( !NT_SUCCESS( ntStatus))
3011 // Attempt to re-insert the directory entry
3014 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
3015 pSrcCcb->DirectoryCB,
3018 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3019 AFS_TRACE_LEVEL_ERROR,
3020 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
3021 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3025 try_return( ntStatus);
3029 // Update the object information block, if needed
3032 if( !AFSIsEqualFID( &pSrcObject->FileId,
3036 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
3040 // Remove the old information entry
3043 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3044 &pSrcObject->TreeEntry);
3046 RtlCopyMemory( &pSrcObject->FileId,
3048 sizeof( AFSFileID));
3051 // Insert the entry into the new object table.
3054 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3056 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3059 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3064 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3065 &pSrcObject->TreeEntry)))
3069 // Lost a race, an ObjectInfo object already exists for this FID.
3070 // Let this copy be garbage collected.
3073 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3077 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3081 // Update the hash values for the name trees.
3084 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3087 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3090 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3091 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3092 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3097 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3098 uniShortName.MaximumLength = uniShortName.Length;
3099 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3101 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3104 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3105 AFS_TRACE_LEVEL_VERBOSE,
3106 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3108 &pSrcCcb->DirectoryCB->NameInformation.FileName);
3113 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3120 // Update the file index for the object in the new parent
3123 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3127 // Re-insert the directory entry
3130 AFSInsertDirectoryNode( pTargetParentObject,
3131 pSrcCcb->DirectoryCB,
3135 // Update the parent pointer in the source object if they are different
3138 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
3141 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3143 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3145 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3147 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3149 lCount = AFSObjectInfoIncrement( pTargetParentObject,
3150 AFS_OBJECT_REFERENCE_CHILD);
3152 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3153 AFS_TRACE_LEVEL_VERBOSE,
3154 "AFSSetRenameInfo Increment count on parent object %p Cnt %d\n",
3155 pTargetParentObject,
3158 lCount = AFSObjectInfoDecrement( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
3159 AFS_OBJECT_REFERENCE_CHILD);
3161 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3162 AFS_TRACE_LEVEL_VERBOSE,
3163 "AFSSetRenameInfo Decrement count on parent object %p Cnt %d\n",
3164 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
3167 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
3169 ulNotificationAction = FILE_ACTION_ADDED;
3174 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3178 // Now update the notification for the target file
3181 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
3183 (ULONG)ulNotifyFilter,
3184 (ULONG)ulNotificationAction);
3187 // If we performed the rename of the target because it existed, we now need to
3188 // delete the tmp target we created above
3191 if( bTargetEntryExists)
3194 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3195 AFS_TRACE_LEVEL_VERBOSE,
3196 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3198 &pTargetDirEntry->NameInformation.FileName);
3200 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3203 // Try and purge the cache map if this is a file
3206 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3207 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3208 pTargetDirEntry->DirOpenReferenceCount > 1)
3211 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3214 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3216 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3218 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3219 AFS_TRACE_LEVEL_VERBOSE,
3220 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3221 &pTargetDirEntry->NameInformation.FileName,
3226 ASSERT( lCount >= 0);
3231 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3232 AFS_TRACE_LEVEL_VERBOSE,
3233 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3235 &pTargetDirEntry->NameInformation.FileName);
3237 AFSDeleteDirEntry( pTargetParentObject,
3241 pTargetDirEntry = NULL;
3243 if ( pTargetFcb != NULL)
3247 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3248 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3251 if( bReleaseTargetDirLock)
3253 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3255 bReleaseTargetDirLock = FALSE;
3258 if( bReleaseSourceDirLock)
3261 AFSReleaseResource( pSourceDirLock);
3263 bReleaseSourceDirLock = FALSE;
3267 // MmForceSectionClosed() can eventually call back into AFSCleanup
3268 // which will need to acquire Fcb->Resource exclusively. Failure
3269 // to obtain it here before holding the SectionObjectResource will
3270 // permit the locks to be obtained out of order risking a deadlock.
3273 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3274 AFS_TRACE_LEVEL_VERBOSE,
3275 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3276 &pTargetFcb->NPFcb->Resource,
3277 PsGetCurrentThread());
3279 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3282 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3283 AFS_TRACE_LEVEL_VERBOSE,
3284 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3285 &pTargetFcb->NPFcb->SectionObjectResource,
3286 PsGetCurrentThread());
3288 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3292 // Close the section in the event it was mapped
3295 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3299 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3300 AFS_TRACE_LEVEL_ERROR,
3301 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3305 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3306 AFS_TRACE_LEVEL_VERBOSE,
3307 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3308 &pTargetFcb->NPFcb->SectionObjectResource,
3309 PsGetCurrentThread());
3311 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3313 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3314 AFS_TRACE_LEVEL_VERBOSE,
3315 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3316 &pTargetFcb->NPFcb->Resource,
3317 PsGetCurrentThread());
3319 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3325 if( !NT_SUCCESS( ntStatus))
3328 if( bTargetEntryExists)
3330 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
3336 if( pTargetDirEntry != NULL)
3339 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3341 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3342 AFS_TRACE_LEVEL_VERBOSE,
3343 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3344 &pTargetDirEntry->NameInformation.FileName,
3349 ASSERT( lCount >= 0);
3352 if( bReleaseTargetDirLock)
3355 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3358 if( bReleaseSourceDirLock)
3361 AFSReleaseResource( pSourceDirLock);
3365 if ( bDereferenceTargetParentObject)
3368 ObDereferenceObject( pTargetParentFileObj);
3375 AFSSetPositionInfo( IN PIRP Irp,
3376 IN AFSDirectoryCB *DirectoryCB)
3378 UNREFERENCED_PARAMETER(DirectoryCB);
3379 NTSTATUS ntStatus = STATUS_SUCCESS;
3380 PFILE_POSITION_INFORMATION pBuffer;
3381 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3383 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3385 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3391 AFSSetAllocationInfo( IN PIRP Irp,
3392 IN AFSDirectoryCB *DirectoryCB)
3394 UNREFERENCED_PARAMETER(DirectoryCB);
3395 NTSTATUS ntStatus = STATUS_SUCCESS;
3396 PFILE_ALLOCATION_INFORMATION pBuffer;
3397 BOOLEAN bReleasePaging = FALSE;
3398 BOOLEAN bTellCc = FALSE;
3399 BOOLEAN bTellService = FALSE;
3400 BOOLEAN bUserMapped = FALSE;
3401 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3402 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3403 AFSFcb *pFcb = NULL;
3404 AFSCcb *pCcb = NULL;
3405 LARGE_INTEGER liSaveAlloc;
3406 LARGE_INTEGER liSaveFileSize;
3407 LARGE_INTEGER liSaveVDL;
3409 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3411 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3413 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3416 // save values to put back
3418 liSaveAlloc = pFcb->Header.AllocationSize;
3419 liSaveFileSize = pFcb->Header.FileSize;
3420 liSaveVDL = pFcb->Header.ValidDataLength;
3422 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3423 pIrpSp->Parameters.SetFile.AdvanceOnly)
3425 return STATUS_SUCCESS ;
3428 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3431 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3432 AFS_TRACE_LEVEL_VERBOSE,
3433 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3434 &pFcb->NPFcb->SectionObjectResource,
3435 PsGetCurrentThread());
3437 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3440 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3441 &pBuffer->AllocationSize);
3443 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3444 AFS_TRACE_LEVEL_VERBOSE,
3445 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3446 &pFcb->NPFcb->SectionObjectResource,
3447 PsGetCurrentThread());
3449 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3452 // Truncating the file
3457 ntStatus = STATUS_USER_MAPPED_FILE ;
3463 // If this is a truncation we need to grab the paging IO resource.
3466 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3467 AFS_TRACE_LEVEL_VERBOSE,
3468 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3469 &pFcb->NPFcb->PagingResource,
3470 PsGetCurrentThread());
3472 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3475 bReleasePaging = TRUE;
3478 // Must drop the Fcb Resource. When changing the file size
3479 // a deadlock can occur with Trend Micro's filter if the file
3480 // size is set to zero.
3483 AFSReleaseResource( &pFcb->NPFcb->Resource);
3485 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3487 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3490 // Tell Cc that Allocation is moved.
3494 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3497 // We are pulling the EOF back as well so we need to tell
3500 bTellService = TRUE;
3502 pFcb->Header.FileSize = pBuffer->AllocationSize;
3504 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3512 // Tell Cc if allocation is increased.
3515 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3516 AFS_TRACE_LEVEL_VERBOSE,
3517 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3518 &pFcb->NPFcb->PagingResource,
3519 PsGetCurrentThread());
3521 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3524 bReleasePaging = TRUE;
3527 // Must drop the Fcb Resource. When changing the file size
3528 // a deadlock can occur with Trend Micro's filter if the file
3529 // size is set to zero.
3532 AFSReleaseResource( &pFcb->NPFcb->Resource);
3534 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3536 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3538 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3542 // Now Tell the server if we have to
3546 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3547 pFcb->ObjectInformation,
3551 if (NT_SUCCESS(ntStatus))
3554 // Trim extents if we told the service - the update has done an implicit
3555 // trim at the service.
3559 AFSTrimExtents( pFcb,
3560 &pFcb->Header.FileSize);
3563 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3565 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3568 CcIsFileCached( pFileObject))
3570 CcSetFileSizes( pFileObject,
3571 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3577 // Put the saved values back
3579 pFcb->Header.ValidDataLength = liSaveVDL;
3580 pFcb->Header.FileSize = liSaveFileSize;
3581 pFcb->Header.AllocationSize = liSaveAlloc;
3582 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3583 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3589 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3591 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3599 AFSSetEndOfFileInfo( IN PIRP Irp,
3600 IN AFSDirectoryCB *DirectoryCB)
3602 UNREFERENCED_PARAMETER(DirectoryCB);
3603 NTSTATUS ntStatus = STATUS_SUCCESS;
3604 PFILE_END_OF_FILE_INFORMATION pBuffer;
3605 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3606 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3607 LARGE_INTEGER liSaveSize;
3608 LARGE_INTEGER liSaveVDL;
3609 LARGE_INTEGER liSaveAlloc;
3610 BOOLEAN bModified = FALSE;
3611 BOOLEAN bReleasePaging = FALSE;
3612 BOOLEAN bTruncated = FALSE;
3613 BOOLEAN bUserMapped = FALSE;
3614 AFSFcb *pFcb = NULL;
3615 AFSCcb *pCcb = NULL;
3617 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3619 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3621 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3623 liSaveSize = pFcb->Header.FileSize;
3624 liSaveAlloc = pFcb->Header.AllocationSize;
3625 liSaveVDL = pFcb->Header.ValidDataLength;
3627 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3628 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3631 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3634 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3635 AFS_TRACE_LEVEL_VERBOSE,
3636 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3637 &pFcb->NPFcb->SectionObjectResource,
3638 PsGetCurrentThread());
3640 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3643 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3644 &pBuffer->EndOfFile);
3646 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3647 AFS_TRACE_LEVEL_VERBOSE,
3648 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3649 &pFcb->NPFcb->SectionObjectResource,
3650 PsGetCurrentThread());
3652 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3654 // Truncating the file
3658 ntStatus = STATUS_USER_MAPPED_FILE;
3664 // If this is a truncation we need to grab the paging
3667 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3668 AFS_TRACE_LEVEL_VERBOSE,
3669 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3670 &pFcb->NPFcb->PagingResource,
3671 PsGetCurrentThread());
3673 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3676 bReleasePaging = TRUE;
3679 // Must drop the Fcb Resource. When changing the file size
3680 // a deadlock can occur with Trend Micro's filter if the file
3681 // size is set to zero.
3684 AFSReleaseResource( &pFcb->NPFcb->Resource);
3686 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3688 pFcb->Header.FileSize = pBuffer->EndOfFile;
3690 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3692 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3694 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3697 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3709 // extending the file, move EOF
3713 // If this is a truncation we need to grab the paging
3716 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3717 AFS_TRACE_LEVEL_VERBOSE,
3718 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3719 &pFcb->NPFcb->PagingResource,
3720 PsGetCurrentThread());
3722 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3725 bReleasePaging = TRUE;
3728 // Must drop the Fcb Resource. When changing the file size
3729 // a deadlock can occur with Trend Micro's filter if the file
3730 // size is set to zero.
3733 AFSReleaseResource( &pFcb->NPFcb->Resource);
3735 pFcb->Header.FileSize = pBuffer->EndOfFile;
3737 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3739 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3742 // And Allocation as needed.
3744 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3746 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3756 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3758 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3764 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3765 pFcb->ObjectInformation,
3768 if( NT_SUCCESS(ntStatus))
3771 // We are now good to go so tell CC.
3773 CcSetFileSizes( pFileObject,
3774 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3777 // And give up those extents
3782 AFSTrimExtents( pFcb,
3783 &pFcb->Header.FileSize);
3788 pFcb->Header.ValidDataLength = liSaveVDL;
3789 pFcb->Header.FileSize = liSaveSize;
3790 pFcb->Header.AllocationSize = liSaveAlloc;
3791 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3792 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3799 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3801 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3809 AFSProcessShareSetInfo( IN IRP *Irp,
3814 UNREFERENCED_PARAMETER(Fcb);
3815 NTSTATUS ntStatus = STATUS_SUCCESS;
3816 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3817 FILE_INFORMATION_CLASS ulFileInformationClass;
3818 void *pPipeInfo = NULL;
3822 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3824 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3825 AFS_TRACE_LEVEL_VERBOSE,
3826 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3827 &Ccb->DirectoryCB->NameInformation.FileName,
3828 ulFileInformationClass);
3830 pPipeInfo = AFSLockSystemBuffer( Irp,
3831 pIrpSp->Parameters.SetFile.Length);
3833 if( pPipeInfo == NULL)
3836 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3837 AFS_TRACE_LEVEL_ERROR,
3838 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3839 &Ccb->DirectoryCB->NameInformation.FileName);
3841 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3845 // Send the request to the service
3848 ntStatus = AFSNotifySetPipeInfo( Ccb,
3849 (ULONG)ulFileInformationClass,
3850 pIrpSp->Parameters.SetFile.Length,
3853 if( !NT_SUCCESS( ntStatus))
3856 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3857 AFS_TRACE_LEVEL_ERROR,
3858 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3859 &Ccb->DirectoryCB->NameInformation.FileName,
3862 try_return( ntStatus);
3865 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3866 AFS_TRACE_LEVEL_VERBOSE,
3867 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3868 &Ccb->DirectoryCB->NameInformation.FileName,
3869 ulFileInformationClass);
3880 AFSProcessShareQueryInfo( IN IRP *Irp,
3885 UNREFERENCED_PARAMETER(Fcb);
3886 NTSTATUS ntStatus = STATUS_SUCCESS;
3887 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3888 FILE_INFORMATION_CLASS ulFileInformationClass;
3889 void *pPipeInfo = NULL;
3894 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3896 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3897 AFS_TRACE_LEVEL_VERBOSE,
3898 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3899 &Ccb->DirectoryCB->NameInformation.FileName,
3900 ulFileInformationClass);
3902 pPipeInfo = AFSLockSystemBuffer( Irp,
3903 pIrpSp->Parameters.QueryFile.Length);
3905 if( pPipeInfo == NULL)
3908 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3909 AFS_TRACE_LEVEL_ERROR,
3910 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3911 &Ccb->DirectoryCB->NameInformation.FileName);
3913 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3917 // Send the request to the service
3920 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3921 (ULONG)ulFileInformationClass,
3922 pIrpSp->Parameters.QueryFile.Length,
3924 (ULONG *)&Irp->IoStatus.Information);
3926 if( !NT_SUCCESS( ntStatus))
3929 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3930 AFS_TRACE_LEVEL_ERROR,
3931 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3932 &Ccb->DirectoryCB->NameInformation.FileName,
3935 try_return( ntStatus);
3938 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3939 AFS_TRACE_LEVEL_VERBOSE,
3940 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3941 &Ccb->DirectoryCB->NameInformation.FileName,
3942 ulFileInformationClass);
3953 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3956 IN OUT LONG *Length)
3959 UNREFERENCED_PARAMETER(Fcb);
3960 UNREFERENCED_PARAMETER(Ccb);
3961 NTSTATUS ntStatus = STATUS_SUCCESS;
3962 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3963 FILE_INFORMATION_CLASS ulFileInformationClass;
3968 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3970 switch( ulFileInformationClass)
3973 case FileBasicInformation:
3976 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3977 AFS_TRACE_LEVEL_VERBOSE,
3978 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3980 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3982 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3984 pBasic->CreationTime.QuadPart = 0;
3985 pBasic->LastAccessTime.QuadPart = 0;
3986 pBasic->ChangeTime.QuadPart = 0;
3987 pBasic->LastWriteTime.QuadPart = 0;
3988 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
3990 *Length -= sizeof( FILE_BASIC_INFORMATION);
3994 ntStatus = STATUS_BUFFER_TOO_SMALL;
4000 case FileStandardInformation:
4003 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4004 AFS_TRACE_LEVEL_VERBOSE,
4005 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
4007 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
4009 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4011 pStandard->NumberOfLinks = 1;
4012 pStandard->DeletePending = 0;
4013 pStandard->AllocationSize.QuadPart = 0;
4014 pStandard->EndOfFile.QuadPart = 0;
4015 pStandard->Directory = 0;
4017 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4021 ntStatus = STATUS_BUFFER_TOO_SMALL;
4027 case FileNormalizedNameInformation:
4028 case FileNameInformation:
4031 ULONG ulCopyLength = 0;
4032 AFSFcb *pFcb = NULL;
4033 AFSCcb *pCcb = NULL;
4034 USHORT usFullNameLength = 0;
4035 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4036 UNICODE_STRING uniName;
4038 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4039 AFS_TRACE_LEVEL_VERBOSE,
4040 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
4042 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4043 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4045 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4047 ntStatus = STATUS_BUFFER_TOO_SMALL;
4051 RtlZeroMemory( pNameInfo,
4054 usFullNameLength = sizeof( WCHAR) +
4055 AFSServerName.Length +
4056 pCcb->FullFileName.Length;
4058 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4060 ulCopyLength = (LONG)usFullNameLength;
4064 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4065 ntStatus = STATUS_BUFFER_OVERFLOW;
4068 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4070 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4072 if( ulCopyLength > 0)
4075 pNameInfo->FileName[ 0] = L'\\';
4076 ulCopyLength -= sizeof( WCHAR);
4078 *Length -= sizeof( WCHAR);
4080 if( ulCopyLength >= AFSServerName.Length)
4083 RtlCopyMemory( &pNameInfo->FileName[ 1],
4084 AFSServerName.Buffer,
4085 AFSServerName.Length);
4087 ulCopyLength -= AFSServerName.Length;
4088 *Length -= AFSServerName.Length;
4090 if( ulCopyLength >= pCcb->FullFileName.Length)
4093 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4094 pCcb->FullFileName.Buffer,
4095 pCcb->FullFileName.Length);
4097 ulCopyLength -= pCcb->FullFileName.Length;
4098 *Length -= pCcb->FullFileName.Length;
4100 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4101 uniName.MaximumLength = uniName.Length;
4102 uniName.Buffer = pNameInfo->FileName;
4107 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4108 pCcb->FullFileName.Buffer,
4111 *Length -= ulCopyLength;
4113 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4114 uniName.MaximumLength = uniName.Length;
4115 uniName.Buffer = pNameInfo->FileName;
4118 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4119 AFS_TRACE_LEVEL_VERBOSE,
4120 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4128 case FileInternalInformation:
4131 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4133 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4134 AFS_TRACE_LEVEL_VERBOSE,
4135 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
4137 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4140 pInternalInfo->IndexNumber.HighPart = 0;
4142 pInternalInfo->IndexNumber.LowPart = 0;
4144 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4149 ntStatus = STATUS_BUFFER_TOO_SMALL;
4155 case FileAllInformation:
4157 ntStatus = STATUS_INVALID_PARAMETER;
4159 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4160 AFS_TRACE_LEVEL_WARNING,
4161 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
4166 case FileEaInformation:
4168 ntStatus = STATUS_INVALID_PARAMETER;
4170 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4171 AFS_TRACE_LEVEL_WARNING,
4172 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
4177 case FilePositionInformation:
4179 ntStatus = STATUS_INVALID_PARAMETER;
4181 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4182 AFS_TRACE_LEVEL_WARNING,
4183 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
4188 case FileAlternateNameInformation:
4190 ntStatus = STATUS_INVALID_PARAMETER;
4192 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4193 AFS_TRACE_LEVEL_WARNING,
4194 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
4199 case FileNetworkOpenInformation:
4201 ntStatus = STATUS_INVALID_PARAMETER;
4203 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4204 AFS_TRACE_LEVEL_WARNING,
4205 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
4210 case FileStreamInformation:
4212 ntStatus = STATUS_INVALID_PARAMETER;
4214 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4215 AFS_TRACE_LEVEL_WARNING,
4216 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
4221 case FileAttributeTagInformation:
4223 ntStatus = STATUS_INVALID_PARAMETER;
4225 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4226 AFS_TRACE_LEVEL_WARNING,
4227 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
4232 case FileRemoteProtocolInformation:
4234 ntStatus = STATUS_INVALID_PARAMETER;
4236 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4237 AFS_TRACE_LEVEL_WARNING,
4238 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
4243 case FileNetworkPhysicalNameInformation:
4245 ntStatus = STATUS_INVALID_PARAMETER;
4247 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4248 AFS_TRACE_LEVEL_WARNING,
4249 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
4256 ntStatus = STATUS_INVALID_PARAMETER;
4258 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4259 AFS_TRACE_LEVEL_WARNING,
4260 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4261 ulFileInformationClass);
4268 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4269 AFS_TRACE_LEVEL_VERBOSE,
4270 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",