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 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
3151 ulNotificationAction = FILE_ACTION_ADDED;
3156 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3160 // Now update the notification for the target file
3163 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
3165 (ULONG)ulNotifyFilter,
3166 (ULONG)ulNotificationAction);
3169 // If we performed the rename of the target because it existed, we now need to
3170 // delete the tmp target we created above
3173 if( bTargetEntryExists)
3176 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3177 AFS_TRACE_LEVEL_VERBOSE,
3178 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3180 &pTargetDirEntry->NameInformation.FileName);
3182 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3185 // Try and purge the cache map if this is a file
3188 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3189 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3190 pTargetDirEntry->DirOpenReferenceCount > 1)
3193 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3196 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3198 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3200 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3201 AFS_TRACE_LEVEL_VERBOSE,
3202 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3203 &pTargetDirEntry->NameInformation.FileName,
3208 ASSERT( lCount >= 0);
3213 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3214 AFS_TRACE_LEVEL_VERBOSE,
3215 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3217 &pTargetDirEntry->NameInformation.FileName);
3219 AFSDeleteDirEntry( pTargetParentObject,
3223 pTargetDirEntry = NULL;
3225 if ( pTargetFcb != NULL)
3229 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3230 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3233 if( bReleaseTargetDirLock)
3235 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3237 bReleaseTargetDirLock = FALSE;
3240 if( bReleaseSourceDirLock)
3243 AFSReleaseResource( pSourceDirLock);
3245 bReleaseSourceDirLock = FALSE;
3249 // MmForceSectionClosed() can eventually call back into AFSCleanup
3250 // which will need to acquire Fcb->Resource exclusively. Failure
3251 // to obtain it here before holding the SectionObjectResource will
3252 // permit the locks to be obtained out of order risking a deadlock.
3255 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3256 AFS_TRACE_LEVEL_VERBOSE,
3257 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3258 &pTargetFcb->NPFcb->Resource,
3259 PsGetCurrentThread());
3261 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3264 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3265 AFS_TRACE_LEVEL_VERBOSE,
3266 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3267 &pTargetFcb->NPFcb->SectionObjectResource,
3268 PsGetCurrentThread());
3270 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3274 // Close the section in the event it was mapped
3277 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3281 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3282 AFS_TRACE_LEVEL_ERROR,
3283 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3287 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3288 AFS_TRACE_LEVEL_VERBOSE,
3289 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3290 &pTargetFcb->NPFcb->SectionObjectResource,
3291 PsGetCurrentThread());
3293 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3295 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3296 AFS_TRACE_LEVEL_VERBOSE,
3297 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3298 &pTargetFcb->NPFcb->Resource,
3299 PsGetCurrentThread());
3301 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3307 if( !NT_SUCCESS( ntStatus))
3310 if( bTargetEntryExists)
3312 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
3318 if( pTargetDirEntry != NULL)
3321 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3323 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3324 AFS_TRACE_LEVEL_VERBOSE,
3325 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3326 &pTargetDirEntry->NameInformation.FileName,
3331 ASSERT( lCount >= 0);
3334 if( bReleaseTargetDirLock)
3337 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3340 if( bReleaseSourceDirLock)
3343 AFSReleaseResource( pSourceDirLock);
3347 if ( bDereferenceTargetParentObject)
3350 ObDereferenceObject( pTargetParentFileObj);
3357 AFSSetPositionInfo( IN PIRP Irp,
3358 IN AFSDirectoryCB *DirectoryCB)
3360 UNREFERENCED_PARAMETER(DirectoryCB);
3361 NTSTATUS ntStatus = STATUS_SUCCESS;
3362 PFILE_POSITION_INFORMATION pBuffer;
3363 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3365 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3367 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3373 AFSSetAllocationInfo( IN PIRP Irp,
3374 IN AFSDirectoryCB *DirectoryCB)
3376 UNREFERENCED_PARAMETER(DirectoryCB);
3377 NTSTATUS ntStatus = STATUS_SUCCESS;
3378 PFILE_ALLOCATION_INFORMATION pBuffer;
3379 BOOLEAN bReleasePaging = FALSE;
3380 BOOLEAN bTellCc = FALSE;
3381 BOOLEAN bTellService = FALSE;
3382 BOOLEAN bUserMapped = FALSE;
3383 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3384 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3385 AFSFcb *pFcb = NULL;
3386 AFSCcb *pCcb = NULL;
3387 LARGE_INTEGER liSaveAlloc;
3388 LARGE_INTEGER liSaveFileSize;
3389 LARGE_INTEGER liSaveVDL;
3391 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3393 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3395 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3398 // save values to put back
3400 liSaveAlloc = pFcb->Header.AllocationSize;
3401 liSaveFileSize = pFcb->Header.FileSize;
3402 liSaveVDL = pFcb->Header.ValidDataLength;
3404 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3405 pIrpSp->Parameters.SetFile.AdvanceOnly)
3407 return STATUS_SUCCESS ;
3410 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3413 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3414 AFS_TRACE_LEVEL_VERBOSE,
3415 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3416 &pFcb->NPFcb->SectionObjectResource,
3417 PsGetCurrentThread());
3419 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3422 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3423 &pBuffer->AllocationSize);
3425 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3426 AFS_TRACE_LEVEL_VERBOSE,
3427 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3428 &pFcb->NPFcb->SectionObjectResource,
3429 PsGetCurrentThread());
3431 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3434 // Truncating the file
3439 ntStatus = STATUS_USER_MAPPED_FILE ;
3445 // If this is a truncation we need to grab the paging IO resource.
3448 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3449 AFS_TRACE_LEVEL_VERBOSE,
3450 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3451 &pFcb->NPFcb->PagingResource,
3452 PsGetCurrentThread());
3454 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3457 bReleasePaging = TRUE;
3460 // Must drop the Fcb Resource. When changing the file size
3461 // a deadlock can occur with Trend Micro's filter if the file
3462 // size is set to zero.
3465 AFSReleaseResource( &pFcb->NPFcb->Resource);
3467 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3469 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3472 // Tell Cc that Allocation is moved.
3476 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3479 // We are pulling the EOF back as well so we need to tell
3482 bTellService = TRUE;
3484 pFcb->Header.FileSize = pBuffer->AllocationSize;
3486 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3494 // Tell Cc if allocation is increased.
3497 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3498 AFS_TRACE_LEVEL_VERBOSE,
3499 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3500 &pFcb->NPFcb->PagingResource,
3501 PsGetCurrentThread());
3503 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3506 bReleasePaging = TRUE;
3509 // Must drop the Fcb Resource. When changing the file size
3510 // a deadlock can occur with Trend Micro's filter if the file
3511 // size is set to zero.
3514 AFSReleaseResource( &pFcb->NPFcb->Resource);
3516 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3518 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3520 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3524 // Now Tell the server if we have to
3528 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3529 pFcb->ObjectInformation,
3533 if (NT_SUCCESS(ntStatus))
3536 // Trim extents if we told the service - the update has done an implicit
3537 // trim at the service.
3541 AFSTrimExtents( pFcb,
3542 &pFcb->Header.FileSize);
3545 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3547 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3550 CcIsFileCached( pFileObject))
3552 CcSetFileSizes( pFileObject,
3553 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3559 // Put the saved values back
3561 pFcb->Header.ValidDataLength = liSaveVDL;
3562 pFcb->Header.FileSize = liSaveFileSize;
3563 pFcb->Header.AllocationSize = liSaveAlloc;
3564 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3565 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3571 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3573 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3581 AFSSetEndOfFileInfo( IN PIRP Irp,
3582 IN AFSDirectoryCB *DirectoryCB)
3584 UNREFERENCED_PARAMETER(DirectoryCB);
3585 NTSTATUS ntStatus = STATUS_SUCCESS;
3586 PFILE_END_OF_FILE_INFORMATION pBuffer;
3587 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3588 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3589 LARGE_INTEGER liSaveSize;
3590 LARGE_INTEGER liSaveVDL;
3591 LARGE_INTEGER liSaveAlloc;
3592 BOOLEAN bModified = FALSE;
3593 BOOLEAN bReleasePaging = FALSE;
3594 BOOLEAN bTruncated = FALSE;
3595 BOOLEAN bUserMapped = FALSE;
3596 AFSFcb *pFcb = NULL;
3597 AFSCcb *pCcb = NULL;
3599 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3601 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3603 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3605 liSaveSize = pFcb->Header.FileSize;
3606 liSaveAlloc = pFcb->Header.AllocationSize;
3607 liSaveVDL = pFcb->Header.ValidDataLength;
3609 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3610 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3613 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3616 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3617 AFS_TRACE_LEVEL_VERBOSE,
3618 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3619 &pFcb->NPFcb->SectionObjectResource,
3620 PsGetCurrentThread());
3622 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3625 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3626 &pBuffer->EndOfFile);
3628 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3629 AFS_TRACE_LEVEL_VERBOSE,
3630 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3631 &pFcb->NPFcb->SectionObjectResource,
3632 PsGetCurrentThread());
3634 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3636 // Truncating the file
3640 ntStatus = STATUS_USER_MAPPED_FILE;
3646 // If this is a truncation we need to grab the paging
3649 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3650 AFS_TRACE_LEVEL_VERBOSE,
3651 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3652 &pFcb->NPFcb->PagingResource,
3653 PsGetCurrentThread());
3655 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3658 bReleasePaging = TRUE;
3661 // Must drop the Fcb Resource. When changing the file size
3662 // a deadlock can occur with Trend Micro's filter if the file
3663 // size is set to zero.
3666 AFSReleaseResource( &pFcb->NPFcb->Resource);
3668 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3670 pFcb->Header.FileSize = pBuffer->EndOfFile;
3672 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3674 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3676 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3679 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3691 // extending the file, move EOF
3695 // If this is a truncation we need to grab the paging
3698 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3699 AFS_TRACE_LEVEL_VERBOSE,
3700 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3701 &pFcb->NPFcb->PagingResource,
3702 PsGetCurrentThread());
3704 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3707 bReleasePaging = TRUE;
3710 // Must drop the Fcb Resource. When changing the file size
3711 // a deadlock can occur with Trend Micro's filter if the file
3712 // size is set to zero.
3715 AFSReleaseResource( &pFcb->NPFcb->Resource);
3717 pFcb->Header.FileSize = pBuffer->EndOfFile;
3719 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3721 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3724 // And Allocation as needed.
3726 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3728 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3738 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3740 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3746 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3747 pFcb->ObjectInformation,
3750 if( NT_SUCCESS(ntStatus))
3753 // We are now good to go so tell CC.
3755 CcSetFileSizes( pFileObject,
3756 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3759 // And give up those extents
3764 AFSTrimExtents( pFcb,
3765 &pFcb->Header.FileSize);
3770 pFcb->Header.ValidDataLength = liSaveVDL;
3771 pFcb->Header.FileSize = liSaveSize;
3772 pFcb->Header.AllocationSize = liSaveAlloc;
3773 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3774 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3781 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3783 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3791 AFSProcessShareSetInfo( IN IRP *Irp,
3796 UNREFERENCED_PARAMETER(Fcb);
3797 NTSTATUS ntStatus = STATUS_SUCCESS;
3798 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3799 FILE_INFORMATION_CLASS ulFileInformationClass;
3800 void *pPipeInfo = NULL;
3804 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3806 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3807 AFS_TRACE_LEVEL_VERBOSE,
3808 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3809 &Ccb->DirectoryCB->NameInformation.FileName,
3810 ulFileInformationClass);
3812 pPipeInfo = AFSLockSystemBuffer( Irp,
3813 pIrpSp->Parameters.SetFile.Length);
3815 if( pPipeInfo == NULL)
3818 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3819 AFS_TRACE_LEVEL_ERROR,
3820 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3821 &Ccb->DirectoryCB->NameInformation.FileName);
3823 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3827 // Send the request to the service
3830 ntStatus = AFSNotifySetPipeInfo( Ccb,
3831 (ULONG)ulFileInformationClass,
3832 pIrpSp->Parameters.SetFile.Length,
3835 if( !NT_SUCCESS( ntStatus))
3838 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3839 AFS_TRACE_LEVEL_ERROR,
3840 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3841 &Ccb->DirectoryCB->NameInformation.FileName,
3844 try_return( ntStatus);
3847 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3848 AFS_TRACE_LEVEL_VERBOSE,
3849 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3850 &Ccb->DirectoryCB->NameInformation.FileName,
3851 ulFileInformationClass);
3862 AFSProcessShareQueryInfo( IN IRP *Irp,
3867 UNREFERENCED_PARAMETER(Fcb);
3868 NTSTATUS ntStatus = STATUS_SUCCESS;
3869 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3870 FILE_INFORMATION_CLASS ulFileInformationClass;
3871 void *pPipeInfo = NULL;
3876 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3878 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3879 AFS_TRACE_LEVEL_VERBOSE,
3880 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3881 &Ccb->DirectoryCB->NameInformation.FileName,
3882 ulFileInformationClass);
3884 pPipeInfo = AFSLockSystemBuffer( Irp,
3885 pIrpSp->Parameters.QueryFile.Length);
3887 if( pPipeInfo == NULL)
3890 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3891 AFS_TRACE_LEVEL_ERROR,
3892 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3893 &Ccb->DirectoryCB->NameInformation.FileName);
3895 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3899 // Send the request to the service
3902 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3903 (ULONG)ulFileInformationClass,
3904 pIrpSp->Parameters.QueryFile.Length,
3906 (ULONG *)&Irp->IoStatus.Information);
3908 if( !NT_SUCCESS( ntStatus))
3911 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3912 AFS_TRACE_LEVEL_ERROR,
3913 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3914 &Ccb->DirectoryCB->NameInformation.FileName,
3917 try_return( ntStatus);
3920 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3921 AFS_TRACE_LEVEL_VERBOSE,
3922 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3923 &Ccb->DirectoryCB->NameInformation.FileName,
3924 ulFileInformationClass);
3935 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3938 IN OUT LONG *Length)
3941 UNREFERENCED_PARAMETER(Fcb);
3942 UNREFERENCED_PARAMETER(Ccb);
3943 NTSTATUS ntStatus = STATUS_SUCCESS;
3944 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3945 FILE_INFORMATION_CLASS ulFileInformationClass;
3950 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3952 switch( ulFileInformationClass)
3955 case FileBasicInformation:
3958 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3959 AFS_TRACE_LEVEL_VERBOSE,
3960 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3962 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3964 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3966 pBasic->CreationTime.QuadPart = 0;
3967 pBasic->LastAccessTime.QuadPart = 0;
3968 pBasic->ChangeTime.QuadPart = 0;
3969 pBasic->LastWriteTime.QuadPart = 0;
3970 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
3972 *Length -= sizeof( FILE_BASIC_INFORMATION);
3976 ntStatus = STATUS_BUFFER_TOO_SMALL;
3982 case FileStandardInformation:
3985 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3986 AFS_TRACE_LEVEL_VERBOSE,
3987 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
3989 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3991 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3993 pStandard->NumberOfLinks = 1;
3994 pStandard->DeletePending = 0;
3995 pStandard->AllocationSize.QuadPart = 0;
3996 pStandard->EndOfFile.QuadPart = 0;
3997 pStandard->Directory = 0;
3999 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4003 ntStatus = STATUS_BUFFER_TOO_SMALL;
4009 case FileNormalizedNameInformation:
4010 case FileNameInformation:
4013 ULONG ulCopyLength = 0;
4014 AFSFcb *pFcb = NULL;
4015 AFSCcb *pCcb = NULL;
4016 USHORT usFullNameLength = 0;
4017 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4018 UNICODE_STRING uniName;
4020 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4021 AFS_TRACE_LEVEL_VERBOSE,
4022 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
4024 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4025 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4027 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4029 ntStatus = STATUS_BUFFER_TOO_SMALL;
4033 RtlZeroMemory( pNameInfo,
4036 usFullNameLength = sizeof( WCHAR) +
4037 AFSServerName.Length +
4038 pCcb->FullFileName.Length;
4040 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4042 ulCopyLength = (LONG)usFullNameLength;
4046 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4047 ntStatus = STATUS_BUFFER_OVERFLOW;
4050 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4052 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4054 if( ulCopyLength > 0)
4057 pNameInfo->FileName[ 0] = L'\\';
4058 ulCopyLength -= sizeof( WCHAR);
4060 *Length -= sizeof( WCHAR);
4062 if( ulCopyLength >= AFSServerName.Length)
4065 RtlCopyMemory( &pNameInfo->FileName[ 1],
4066 AFSServerName.Buffer,
4067 AFSServerName.Length);
4069 ulCopyLength -= AFSServerName.Length;
4070 *Length -= AFSServerName.Length;
4072 if( ulCopyLength >= pCcb->FullFileName.Length)
4075 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4076 pCcb->FullFileName.Buffer,
4077 pCcb->FullFileName.Length);
4079 ulCopyLength -= pCcb->FullFileName.Length;
4080 *Length -= pCcb->FullFileName.Length;
4082 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4083 uniName.MaximumLength = uniName.Length;
4084 uniName.Buffer = pNameInfo->FileName;
4089 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4090 pCcb->FullFileName.Buffer,
4093 *Length -= ulCopyLength;
4095 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4096 uniName.MaximumLength = uniName.Length;
4097 uniName.Buffer = pNameInfo->FileName;
4100 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4101 AFS_TRACE_LEVEL_VERBOSE,
4102 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4110 case FileInternalInformation:
4113 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4115 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4116 AFS_TRACE_LEVEL_VERBOSE,
4117 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
4119 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4122 pInternalInfo->IndexNumber.HighPart = 0;
4124 pInternalInfo->IndexNumber.LowPart = 0;
4126 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4131 ntStatus = STATUS_BUFFER_TOO_SMALL;
4137 case FileAllInformation:
4139 ntStatus = STATUS_INVALID_PARAMETER;
4141 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4142 AFS_TRACE_LEVEL_WARNING,
4143 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
4148 case FileEaInformation:
4150 ntStatus = STATUS_INVALID_PARAMETER;
4152 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4153 AFS_TRACE_LEVEL_WARNING,
4154 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
4159 case FilePositionInformation:
4161 ntStatus = STATUS_INVALID_PARAMETER;
4163 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4164 AFS_TRACE_LEVEL_WARNING,
4165 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
4170 case FileAlternateNameInformation:
4172 ntStatus = STATUS_INVALID_PARAMETER;
4174 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4175 AFS_TRACE_LEVEL_WARNING,
4176 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
4181 case FileNetworkOpenInformation:
4183 ntStatus = STATUS_INVALID_PARAMETER;
4185 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4186 AFS_TRACE_LEVEL_WARNING,
4187 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
4192 case FileStreamInformation:
4194 ntStatus = STATUS_INVALID_PARAMETER;
4196 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4197 AFS_TRACE_LEVEL_WARNING,
4198 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
4203 case FileAttributeTagInformation:
4205 ntStatus = STATUS_INVALID_PARAMETER;
4207 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4208 AFS_TRACE_LEVEL_WARNING,
4209 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
4214 case FileRemoteProtocolInformation:
4216 ntStatus = STATUS_INVALID_PARAMETER;
4218 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4219 AFS_TRACE_LEVEL_WARNING,
4220 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
4225 case FileNetworkPhysicalNameInformation:
4227 ntStatus = STATUS_INVALID_PARAMETER;
4229 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4230 AFS_TRACE_LEVEL_WARNING,
4231 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
4238 ntStatus = STATUS_INVALID_PARAMETER;
4240 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4241 AFS_TRACE_LEVEL_WARNING,
4242 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4243 ulFileInformationClass);
4250 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4251 AFS_TRACE_LEVEL_VERBOSE,
4252 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",