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);
2879 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2880 AFS_TRACE_LEVEL_VERBOSE,
2881 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2882 &pTargetDirEntry->NameInformation.FileName,
2887 ASSERT( lCount >= 0);
2889 if( !bReplaceIfExists)
2892 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2893 AFS_TRACE_LEVEL_ERROR,
2894 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2895 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2896 &pTargetDirEntry->NameInformation.FileName);
2898 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2901 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2902 AFS_TRACE_LEVEL_ERROR,
2903 "AFSSetRenameInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2904 &pTargetDirEntry->NameInformation.FileName,
2906 pTargetDirEntry->DirOpenReferenceCount);
2909 // Pull the directory entry from the parent
2912 AFSRemoveDirNodeFromParent( pTargetParentObject,
2916 bTargetEntryExists = TRUE;
2920 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2921 AFS_TRACE_LEVEL_VERBOSE,
2922 "AFSSetRenameInfo Target does NOT exist, normal rename\n");
2926 // We need to remove the DirEntry from the parent node, update the index
2927 // and reinsert it into the parent tree. Note that for entries with the
2928 // same parent we do not pull the node from the enumeration list
2931 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2932 pSrcCcb->DirectoryCB,
2936 // OK, this is a simple rename. Issue the rename
2937 // request to the service.
2940 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2941 &pSrcCcb->AuthGroup,
2942 pSrcFcb->ObjectInformation->ParentObjectInformation,
2943 pTargetDcb->ObjectInformation,
2944 pSrcCcb->DirectoryCB,
2948 if( !NT_SUCCESS( ntStatus))
2952 // Attempt to re-insert the directory entry
2955 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2956 pSrcCcb->DirectoryCB,
2959 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2960 AFS_TRACE_LEVEL_ERROR,
2961 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2962 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2966 try_return( ntStatus);
2970 // Set the notification up for the source file
2973 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2974 !bTargetEntryExists)
2977 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2982 ulNotificationAction = FILE_ACTION_REMOVED;
2985 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2988 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2993 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2996 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2998 (ULONG)ulNotifyFilter,
2999 (ULONG)ulNotificationAction);
3002 // Update the name in the dir entry.
3005 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
3008 if( !NT_SUCCESS( ntStatus))
3012 // Attempt to re-insert the directory entry
3015 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
3016 pSrcCcb->DirectoryCB,
3019 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3020 AFS_TRACE_LEVEL_ERROR,
3021 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
3022 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3026 try_return( ntStatus);
3030 // Update the object information block, if needed
3033 if( !AFSIsEqualFID( &pSrcObject->FileId,
3037 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
3041 // Remove the old information entry
3044 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3045 &pSrcObject->TreeEntry);
3047 RtlCopyMemory( &pSrcObject->FileId,
3049 sizeof( AFSFileID));
3052 // Insert the entry into the new object table.
3055 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3057 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3060 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3065 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3066 &pSrcObject->TreeEntry)))
3070 // Lost a race, an ObjectInfo object already exists for this FID.
3071 // Let this copy be garbage collected.
3074 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3078 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3082 // Update the hash values for the name trees.
3085 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3088 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3091 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3092 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3093 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3098 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3099 uniShortName.MaximumLength = uniShortName.Length;
3100 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3102 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3105 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3106 AFS_TRACE_LEVEL_VERBOSE,
3107 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3109 &pSrcCcb->DirectoryCB->NameInformation.FileName);
3114 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3121 // Update the file index for the object in the new parent
3124 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3128 // Re-insert the directory entry
3131 AFSInsertDirectoryNode( pTargetParentObject,
3132 pSrcCcb->DirectoryCB,
3136 // Update the parent pointer in the source object if they are different
3139 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
3142 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3144 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3146 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3148 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3150 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
3152 ulNotificationAction = FILE_ACTION_ADDED;
3157 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3161 // Now update the notification for the target file
3164 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
3166 (ULONG)ulNotifyFilter,
3167 (ULONG)ulNotificationAction);
3170 // If we performed the rename of the target because it existed, we now need to
3171 // delete the tmp target we created above
3174 if( bTargetEntryExists)
3177 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3178 AFS_TRACE_LEVEL_VERBOSE,
3179 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3181 &pTargetDirEntry->NameInformation.FileName);
3183 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3186 // Try and purge the cache map if this is a file
3189 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3190 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3191 pTargetDirEntry->DirOpenReferenceCount > 1)
3194 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3197 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3199 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3201 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3202 AFS_TRACE_LEVEL_VERBOSE,
3203 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3204 &pTargetDirEntry->NameInformation.FileName,
3209 ASSERT( lCount >= 0);
3214 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3215 AFS_TRACE_LEVEL_VERBOSE,
3216 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3218 &pTargetDirEntry->NameInformation.FileName);
3220 AFSDeleteDirEntry( pTargetParentObject,
3224 pTargetDirEntry = NULL;
3226 if ( pTargetFcb != NULL)
3230 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3231 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3234 if( bReleaseTargetDirLock)
3236 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3238 bReleaseTargetDirLock = FALSE;
3241 if( bReleaseSourceDirLock)
3244 AFSReleaseResource( pSourceDirLock);
3246 bReleaseSourceDirLock = FALSE;
3250 // MmForceSectionClosed() can eventually call back into AFSCleanup
3251 // which will need to acquire Fcb->Resource exclusively. Failure
3252 // to obtain it here before holding the SectionObjectResource will
3253 // permit the locks to be obtained out of order risking a deadlock.
3256 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3257 AFS_TRACE_LEVEL_VERBOSE,
3258 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3259 &pTargetFcb->NPFcb->Resource,
3260 PsGetCurrentThread());
3262 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3265 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3266 AFS_TRACE_LEVEL_VERBOSE,
3267 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3268 &pTargetFcb->NPFcb->SectionObjectResource,
3269 PsGetCurrentThread());
3271 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3275 // Close the section in the event it was mapped
3278 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3282 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3283 AFS_TRACE_LEVEL_ERROR,
3284 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3288 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3289 AFS_TRACE_LEVEL_VERBOSE,
3290 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3291 &pTargetFcb->NPFcb->SectionObjectResource,
3292 PsGetCurrentThread());
3294 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3296 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3297 AFS_TRACE_LEVEL_VERBOSE,
3298 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3299 &pTargetFcb->NPFcb->Resource,
3300 PsGetCurrentThread());
3302 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3308 if( !NT_SUCCESS( ntStatus))
3311 if( bTargetEntryExists)
3313 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
3319 if( pTargetDirEntry != NULL)
3322 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3324 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3325 AFS_TRACE_LEVEL_VERBOSE,
3326 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3327 &pTargetDirEntry->NameInformation.FileName,
3332 ASSERT( lCount >= 0);
3335 if( bReleaseTargetDirLock)
3338 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3341 if( bReleaseSourceDirLock)
3344 AFSReleaseResource( pSourceDirLock);
3348 if ( bDereferenceTargetParentObject)
3351 ObDereferenceObject( pTargetParentFileObj);
3358 AFSSetPositionInfo( IN PIRP Irp,
3359 IN AFSDirectoryCB *DirectoryCB)
3361 UNREFERENCED_PARAMETER(DirectoryCB);
3362 NTSTATUS ntStatus = STATUS_SUCCESS;
3363 PFILE_POSITION_INFORMATION pBuffer;
3364 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3366 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3368 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3374 AFSSetAllocationInfo( IN PIRP Irp,
3375 IN AFSDirectoryCB *DirectoryCB)
3377 UNREFERENCED_PARAMETER(DirectoryCB);
3378 NTSTATUS ntStatus = STATUS_SUCCESS;
3379 PFILE_ALLOCATION_INFORMATION pBuffer;
3380 BOOLEAN bReleasePaging = FALSE;
3381 BOOLEAN bTellCc = FALSE;
3382 BOOLEAN bTellService = FALSE;
3383 BOOLEAN bUserMapped = FALSE;
3384 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3385 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3386 AFSFcb *pFcb = NULL;
3387 AFSCcb *pCcb = NULL;
3388 LARGE_INTEGER liSaveAlloc;
3389 LARGE_INTEGER liSaveFileSize;
3390 LARGE_INTEGER liSaveVDL;
3392 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3394 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3396 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3399 // save values to put back
3401 liSaveAlloc = pFcb->Header.AllocationSize;
3402 liSaveFileSize = pFcb->Header.FileSize;
3403 liSaveVDL = pFcb->Header.ValidDataLength;
3405 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3406 pIrpSp->Parameters.SetFile.AdvanceOnly)
3408 return STATUS_SUCCESS ;
3411 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3414 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3415 AFS_TRACE_LEVEL_VERBOSE,
3416 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3417 &pFcb->NPFcb->SectionObjectResource,
3418 PsGetCurrentThread());
3420 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3423 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3424 &pBuffer->AllocationSize);
3426 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3427 AFS_TRACE_LEVEL_VERBOSE,
3428 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3429 &pFcb->NPFcb->SectionObjectResource,
3430 PsGetCurrentThread());
3432 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3435 // Truncating the file
3440 ntStatus = STATUS_USER_MAPPED_FILE ;
3446 // If this is a truncation we need to grab the paging IO resource.
3449 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3450 AFS_TRACE_LEVEL_VERBOSE,
3451 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3452 &pFcb->NPFcb->PagingResource,
3453 PsGetCurrentThread());
3455 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3458 bReleasePaging = TRUE;
3461 // Must drop the Fcb Resource. When changing the file size
3462 // a deadlock can occur with Trend Micro's filter if the file
3463 // size is set to zero.
3466 AFSReleaseResource( &pFcb->NPFcb->Resource);
3468 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3470 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3473 // Tell Cc that Allocation is moved.
3477 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3480 // We are pulling the EOF back as well so we need to tell
3483 bTellService = TRUE;
3485 pFcb->Header.FileSize = pBuffer->AllocationSize;
3487 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3495 // Tell Cc if allocation is increased.
3498 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3499 AFS_TRACE_LEVEL_VERBOSE,
3500 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3501 &pFcb->NPFcb->PagingResource,
3502 PsGetCurrentThread());
3504 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3507 bReleasePaging = TRUE;
3510 // Must drop the Fcb Resource. When changing the file size
3511 // a deadlock can occur with Trend Micro's filter if the file
3512 // size is set to zero.
3515 AFSReleaseResource( &pFcb->NPFcb->Resource);
3517 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3519 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3521 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3525 // Now Tell the server if we have to
3529 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3530 pFcb->ObjectInformation,
3534 if (NT_SUCCESS(ntStatus))
3537 // Trim extents if we told the service - the update has done an implicit
3538 // trim at the service.
3542 AFSTrimExtents( pFcb,
3543 &pFcb->Header.FileSize);
3546 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3548 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3551 CcIsFileCached( pFileObject))
3553 CcSetFileSizes( pFileObject,
3554 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3560 // Put the saved values back
3562 pFcb->Header.ValidDataLength = liSaveVDL;
3563 pFcb->Header.FileSize = liSaveFileSize;
3564 pFcb->Header.AllocationSize = liSaveAlloc;
3565 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3566 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3572 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3574 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3582 AFSSetEndOfFileInfo( IN PIRP Irp,
3583 IN AFSDirectoryCB *DirectoryCB)
3585 UNREFERENCED_PARAMETER(DirectoryCB);
3586 NTSTATUS ntStatus = STATUS_SUCCESS;
3587 PFILE_END_OF_FILE_INFORMATION pBuffer;
3588 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3589 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3590 LARGE_INTEGER liSaveSize;
3591 LARGE_INTEGER liSaveVDL;
3592 LARGE_INTEGER liSaveAlloc;
3593 BOOLEAN bModified = FALSE;
3594 BOOLEAN bReleasePaging = FALSE;
3595 BOOLEAN bTruncated = FALSE;
3596 BOOLEAN bUserMapped = FALSE;
3597 AFSFcb *pFcb = NULL;
3598 AFSCcb *pCcb = NULL;
3600 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3602 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3604 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3606 liSaveSize = pFcb->Header.FileSize;
3607 liSaveAlloc = pFcb->Header.AllocationSize;
3608 liSaveVDL = pFcb->Header.ValidDataLength;
3610 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3611 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3614 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3617 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3618 AFS_TRACE_LEVEL_VERBOSE,
3619 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3620 &pFcb->NPFcb->SectionObjectResource,
3621 PsGetCurrentThread());
3623 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3626 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3627 &pBuffer->EndOfFile);
3629 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3630 AFS_TRACE_LEVEL_VERBOSE,
3631 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3632 &pFcb->NPFcb->SectionObjectResource,
3633 PsGetCurrentThread());
3635 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3637 // Truncating the file
3641 ntStatus = STATUS_USER_MAPPED_FILE;
3647 // If this is a truncation we need to grab the paging
3650 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3651 AFS_TRACE_LEVEL_VERBOSE,
3652 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3653 &pFcb->NPFcb->PagingResource,
3654 PsGetCurrentThread());
3656 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3659 bReleasePaging = TRUE;
3662 // Must drop the Fcb Resource. When changing the file size
3663 // a deadlock can occur with Trend Micro's filter if the file
3664 // size is set to zero.
3667 AFSReleaseResource( &pFcb->NPFcb->Resource);
3669 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3671 pFcb->Header.FileSize = pBuffer->EndOfFile;
3673 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3675 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3677 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3680 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3692 // extending the file, move EOF
3696 // If this is a truncation we need to grab the paging
3699 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3700 AFS_TRACE_LEVEL_VERBOSE,
3701 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3702 &pFcb->NPFcb->PagingResource,
3703 PsGetCurrentThread());
3705 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3708 bReleasePaging = TRUE;
3711 // Must drop the Fcb Resource. When changing the file size
3712 // a deadlock can occur with Trend Micro's filter if the file
3713 // size is set to zero.
3716 AFSReleaseResource( &pFcb->NPFcb->Resource);
3718 pFcb->Header.FileSize = pBuffer->EndOfFile;
3720 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3722 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3725 // And Allocation as needed.
3727 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3729 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3739 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3741 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3747 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3748 pFcb->ObjectInformation,
3751 if( NT_SUCCESS(ntStatus))
3754 // We are now good to go so tell CC.
3756 CcSetFileSizes( pFileObject,
3757 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3760 // And give up those extents
3765 AFSTrimExtents( pFcb,
3766 &pFcb->Header.FileSize);
3771 pFcb->Header.ValidDataLength = liSaveVDL;
3772 pFcb->Header.FileSize = liSaveSize;
3773 pFcb->Header.AllocationSize = liSaveAlloc;
3774 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3775 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3782 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3784 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3792 AFSProcessShareSetInfo( IN IRP *Irp,
3797 UNREFERENCED_PARAMETER(Fcb);
3798 NTSTATUS ntStatus = STATUS_SUCCESS;
3799 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3800 FILE_INFORMATION_CLASS ulFileInformationClass;
3801 void *pPipeInfo = NULL;
3805 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3807 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3808 AFS_TRACE_LEVEL_VERBOSE,
3809 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3810 &Ccb->DirectoryCB->NameInformation.FileName,
3811 ulFileInformationClass);
3813 pPipeInfo = AFSLockSystemBuffer( Irp,
3814 pIrpSp->Parameters.SetFile.Length);
3816 if( pPipeInfo == NULL)
3819 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3820 AFS_TRACE_LEVEL_ERROR,
3821 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3822 &Ccb->DirectoryCB->NameInformation.FileName);
3824 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3828 // Send the request to the service
3831 ntStatus = AFSNotifySetPipeInfo( Ccb,
3832 (ULONG)ulFileInformationClass,
3833 pIrpSp->Parameters.SetFile.Length,
3836 if( !NT_SUCCESS( ntStatus))
3839 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3840 AFS_TRACE_LEVEL_ERROR,
3841 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3842 &Ccb->DirectoryCB->NameInformation.FileName,
3845 try_return( ntStatus);
3848 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3849 AFS_TRACE_LEVEL_VERBOSE,
3850 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3851 &Ccb->DirectoryCB->NameInformation.FileName,
3852 ulFileInformationClass);
3863 AFSProcessShareQueryInfo( IN IRP *Irp,
3868 UNREFERENCED_PARAMETER(Fcb);
3869 NTSTATUS ntStatus = STATUS_SUCCESS;
3870 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3871 FILE_INFORMATION_CLASS ulFileInformationClass;
3872 void *pPipeInfo = NULL;
3877 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3879 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3880 AFS_TRACE_LEVEL_VERBOSE,
3881 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3882 &Ccb->DirectoryCB->NameInformation.FileName,
3883 ulFileInformationClass);
3885 pPipeInfo = AFSLockSystemBuffer( Irp,
3886 pIrpSp->Parameters.QueryFile.Length);
3888 if( pPipeInfo == NULL)
3891 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3892 AFS_TRACE_LEVEL_ERROR,
3893 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3894 &Ccb->DirectoryCB->NameInformation.FileName);
3896 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3900 // Send the request to the service
3903 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3904 (ULONG)ulFileInformationClass,
3905 pIrpSp->Parameters.QueryFile.Length,
3907 (ULONG *)&Irp->IoStatus.Information);
3909 if( !NT_SUCCESS( ntStatus))
3912 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3913 AFS_TRACE_LEVEL_ERROR,
3914 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3915 &Ccb->DirectoryCB->NameInformation.FileName,
3918 try_return( ntStatus);
3921 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3922 AFS_TRACE_LEVEL_VERBOSE,
3923 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3924 &Ccb->DirectoryCB->NameInformation.FileName,
3925 ulFileInformationClass);
3936 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3939 IN OUT LONG *Length)
3942 UNREFERENCED_PARAMETER(Fcb);
3943 UNREFERENCED_PARAMETER(Ccb);
3944 NTSTATUS ntStatus = STATUS_SUCCESS;
3945 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3946 FILE_INFORMATION_CLASS ulFileInformationClass;
3951 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3953 switch( ulFileInformationClass)
3956 case FileBasicInformation:
3959 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3960 AFS_TRACE_LEVEL_VERBOSE,
3961 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3963 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3965 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3967 pBasic->CreationTime.QuadPart = 0;
3968 pBasic->LastAccessTime.QuadPart = 0;
3969 pBasic->ChangeTime.QuadPart = 0;
3970 pBasic->LastWriteTime.QuadPart = 0;
3971 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
3973 *Length -= sizeof( FILE_BASIC_INFORMATION);
3977 ntStatus = STATUS_BUFFER_TOO_SMALL;
3983 case FileStandardInformation:
3986 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3987 AFS_TRACE_LEVEL_VERBOSE,
3988 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
3990 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3992 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3994 pStandard->NumberOfLinks = 1;
3995 pStandard->DeletePending = 0;
3996 pStandard->AllocationSize.QuadPart = 0;
3997 pStandard->EndOfFile.QuadPart = 0;
3998 pStandard->Directory = 0;
4000 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4004 ntStatus = STATUS_BUFFER_TOO_SMALL;
4010 case FileNormalizedNameInformation:
4011 case FileNameInformation:
4014 ULONG ulCopyLength = 0;
4015 AFSFcb *pFcb = NULL;
4016 AFSCcb *pCcb = NULL;
4017 USHORT usFullNameLength = 0;
4018 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4019 UNICODE_STRING uniName;
4021 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4022 AFS_TRACE_LEVEL_VERBOSE,
4023 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
4025 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4026 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4028 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4030 ntStatus = STATUS_BUFFER_TOO_SMALL;
4034 RtlZeroMemory( pNameInfo,
4037 usFullNameLength = sizeof( WCHAR) +
4038 AFSServerName.Length +
4039 pCcb->FullFileName.Length;
4041 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4043 ulCopyLength = (LONG)usFullNameLength;
4047 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4048 ntStatus = STATUS_BUFFER_OVERFLOW;
4051 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4053 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4055 if( ulCopyLength > 0)
4058 pNameInfo->FileName[ 0] = L'\\';
4059 ulCopyLength -= sizeof( WCHAR);
4061 *Length -= sizeof( WCHAR);
4063 if( ulCopyLength >= AFSServerName.Length)
4066 RtlCopyMemory( &pNameInfo->FileName[ 1],
4067 AFSServerName.Buffer,
4068 AFSServerName.Length);
4070 ulCopyLength -= AFSServerName.Length;
4071 *Length -= AFSServerName.Length;
4073 if( ulCopyLength >= pCcb->FullFileName.Length)
4076 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4077 pCcb->FullFileName.Buffer,
4078 pCcb->FullFileName.Length);
4080 ulCopyLength -= pCcb->FullFileName.Length;
4081 *Length -= pCcb->FullFileName.Length;
4083 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4084 uniName.MaximumLength = uniName.Length;
4085 uniName.Buffer = pNameInfo->FileName;
4090 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4091 pCcb->FullFileName.Buffer,
4094 *Length -= ulCopyLength;
4096 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4097 uniName.MaximumLength = uniName.Length;
4098 uniName.Buffer = pNameInfo->FileName;
4101 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4102 AFS_TRACE_LEVEL_VERBOSE,
4103 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4111 case FileInternalInformation:
4114 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4116 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4117 AFS_TRACE_LEVEL_VERBOSE,
4118 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
4120 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4123 pInternalInfo->IndexNumber.HighPart = 0;
4125 pInternalInfo->IndexNumber.LowPart = 0;
4127 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4132 ntStatus = STATUS_BUFFER_TOO_SMALL;
4138 case FileAllInformation:
4140 ntStatus = STATUS_INVALID_PARAMETER;
4142 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4143 AFS_TRACE_LEVEL_WARNING,
4144 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
4149 case FileEaInformation:
4151 ntStatus = STATUS_INVALID_PARAMETER;
4153 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4154 AFS_TRACE_LEVEL_WARNING,
4155 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
4160 case FilePositionInformation:
4162 ntStatus = STATUS_INVALID_PARAMETER;
4164 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4165 AFS_TRACE_LEVEL_WARNING,
4166 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
4171 case FileAlternateNameInformation:
4173 ntStatus = STATUS_INVALID_PARAMETER;
4175 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4176 AFS_TRACE_LEVEL_WARNING,
4177 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
4182 case FileNetworkOpenInformation:
4184 ntStatus = STATUS_INVALID_PARAMETER;
4186 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4187 AFS_TRACE_LEVEL_WARNING,
4188 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
4193 case FileStreamInformation:
4195 ntStatus = STATUS_INVALID_PARAMETER;
4197 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4198 AFS_TRACE_LEVEL_WARNING,
4199 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
4204 case FileAttributeTagInformation:
4206 ntStatus = STATUS_INVALID_PARAMETER;
4208 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4209 AFS_TRACE_LEVEL_WARNING,
4210 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
4215 case FileRemoteProtocolInformation:
4217 ntStatus = STATUS_INVALID_PARAMETER;
4219 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4220 AFS_TRACE_LEVEL_WARNING,
4221 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
4226 case FileNetworkPhysicalNameInformation:
4228 ntStatus = STATUS_INVALID_PARAMETER;
4230 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4231 AFS_TRACE_LEVEL_WARNING,
4232 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
4239 ntStatus = STATUS_INVALID_PARAMETER;
4241 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4242 AFS_TRACE_LEVEL_WARNING,
4243 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4244 ulFileInformationClass);
4251 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4252 AFS_TRACE_LEVEL_VERBOSE,
4253 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",