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 NTSTATUS ntStatus = STATUS_SUCCESS;
59 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
60 ULONG ulRequestType = 0;
61 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
64 PFILE_OBJECT pFileObject;
65 BOOLEAN bReleaseMain = FALSE;
67 FILE_INFORMATION_CLASS stFileInformationClass;
75 // Determine the type of request this request is
78 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
80 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
85 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
86 AFS_TRACE_LEVEL_ERROR,
87 "AFSQueryFileInfo Attempted access (%08lX) when pFcb == NULL\n",
90 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
93 lLength = (LONG)pIrpSp->Parameters.QueryFile.Length;
94 stFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
95 pBuffer = Irp->AssociatedIrp.SystemBuffer;
97 RtlZeroMemory( &stAuthGroup,
100 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
101 (ULONGLONG)PsGetCurrentThreadId(),
104 AFSVerifyEntry( &stAuthGroup,
108 // Grab the main shared right off the bat
111 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
112 AFS_TRACE_LEVEL_VERBOSE,
113 "AFSQueryFileInfo Acquiring Fcb lock %08lX SHARED %08lX\n",
114 &pFcb->NPFcb->Resource,
115 PsGetCurrentThread());
117 AFSAcquireShared( &pFcb->NPFcb->Resource,
123 // Don't allow requests against IOCtl nodes
126 if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
129 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
130 AFS_TRACE_LEVEL_VERBOSE,
131 "AFSQueryFileInfo Processing request against SpecialShare Fcb\n");
133 ntStatus = AFSProcessShareQueryInfo( Irp,
137 try_return( ntStatus);
139 else if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
141 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
142 AFS_TRACE_LEVEL_VERBOSE,
143 "AFSQueryFileInfo request against PIOCtl Fcb\n");
145 ntStatus = AFSProcessPIOCtlQueryInfo( Irp,
150 try_return( ntStatus);
153 else if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
155 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
156 AFS_TRACE_LEVEL_VERBOSE,
157 "AFSQueryFileInfo request against Invalid Fcb\n");
159 try_return( ntStatus = STATUS_ACCESS_DENIED);
163 // Process the request
166 switch( stFileInformationClass)
169 case FileAllInformation:
172 PFILE_ALL_INFORMATION pAllInfo;
175 // For the all information class we'll typecast a local
176 // pointer to the output buffer and then call the
177 // individual routines to fill in the buffer.
180 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
182 ntStatus = AFSQueryBasicInfo( Irp,
184 &pAllInfo->BasicInformation,
187 if( !NT_SUCCESS( ntStatus))
190 try_return( ntStatus);
193 ntStatus = AFSQueryStandardInfo( Irp,
195 &pAllInfo->StandardInformation,
198 if( !NT_SUCCESS( ntStatus))
201 try_return( ntStatus);
204 ntStatus = AFSQueryInternalInfo( Irp,
206 &pAllInfo->InternalInformation,
209 if( !NT_SUCCESS( ntStatus))
212 try_return( ntStatus);
215 ntStatus = AFSQueryEaInfo( Irp,
217 &pAllInfo->EaInformation,
220 if( !NT_SUCCESS( ntStatus))
223 try_return( ntStatus);
226 ntStatus = AFSQueryAccess( Irp,
228 &pAllInfo->AccessInformation,
231 if( !NT_SUCCESS( ntStatus))
234 try_return( ntStatus);
237 ntStatus = AFSQueryPositionInfo( Irp,
239 &pAllInfo->PositionInformation,
242 if( !NT_SUCCESS( ntStatus))
245 try_return( ntStatus);
248 ntStatus = AFSQueryMode( Irp,
250 &pAllInfo->ModeInformation,
253 if( !NT_SUCCESS( ntStatus))
256 try_return( ntStatus);
259 ntStatus = AFSQueryAlignment( Irp,
261 &pAllInfo->AlignmentInformation,
264 if( !NT_SUCCESS( ntStatus))
267 try_return( ntStatus);
270 ntStatus = AFSQueryNameInfo( Irp,
272 &pAllInfo->NameInformation,
275 if( !NT_SUCCESS( ntStatus))
278 try_return( ntStatus);
284 case FileBasicInformation:
287 ntStatus = AFSQueryBasicInfo( Irp,
289 (PFILE_BASIC_INFORMATION)pBuffer,
295 case FileStandardInformation:
298 ntStatus = AFSQueryStandardInfo( Irp,
300 (PFILE_STANDARD_INFORMATION)pBuffer,
306 case FileInternalInformation:
309 ntStatus = AFSQueryInternalInfo( Irp,
311 (PFILE_INTERNAL_INFORMATION)pBuffer,
317 case FileEaInformation:
320 ntStatus = AFSQueryEaInfo( Irp,
322 (PFILE_EA_INFORMATION)pBuffer,
328 case FilePositionInformation:
331 ntStatus = AFSQueryPositionInfo( Irp,
333 (PFILE_POSITION_INFORMATION)pBuffer,
339 case FileNormalizedNameInformation:
340 case FileNameInformation:
343 ntStatus = AFSQueryNameInfo( Irp,
345 (PFILE_NAME_INFORMATION)pBuffer,
351 case FileAlternateNameInformation:
354 ntStatus = AFSQueryShortNameInfo( Irp,
356 (PFILE_NAME_INFORMATION)pBuffer,
362 case FileNetworkOpenInformation:
365 ntStatus = AFSQueryNetworkInfo( Irp,
367 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
373 case FileStreamInformation:
376 ntStatus = AFSQueryStreamInfo( Irp,
378 (FILE_STREAM_INFORMATION *)pBuffer,
385 case FileAttributeTagInformation:
388 ntStatus = AFSQueryAttribTagInfo( Irp,
390 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
396 case FileRemoteProtocolInformation:
399 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
401 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
407 case FileNetworkPhysicalNameInformation:
410 ntStatus = AFSQueryPhysicalNameInfo( Irp,
412 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
420 ntStatus = STATUS_INVALID_PARAMETER;
427 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
432 AFSReleaseResource( &pFcb->NPFcb->Resource);
435 if( !NT_SUCCESS( ntStatus) &&
436 ntStatus != STATUS_INVALID_PARAMETER &&
437 ntStatus != STATUS_BUFFER_OVERFLOW)
441 pCcb->DirectoryCB != NULL)
444 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
445 AFS_TRACE_LEVEL_ERROR,
446 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
447 &pCcb->DirectoryCB->NameInformation.FileName,
448 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
449 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
450 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
451 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
456 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
461 "EXCEPTION - AFSQueryFileInfo\n");
463 AFSDumpTraceFilesFnc();
465 ntStatus = STATUS_UNSUCCESSFUL;
470 AFSReleaseResource( &pFcb->NPFcb->Resource);
474 AFSCompleteRequest( Irp,
481 // Function: AFSSetFileInfo
485 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
489 // A status is returned for the function
493 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
497 NTSTATUS ntStatus = STATUS_SUCCESS;
498 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
499 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
502 BOOLEAN bCompleteRequest = TRUE;
503 FILE_INFORMATION_CLASS FileInformationClass;
504 BOOLEAN bCanQueueRequest = FALSE;
505 PFILE_OBJECT pFileObject = NULL;
506 BOOLEAN bReleaseMain = FALSE;
507 BOOLEAN bUpdateFileInfo = FALSE;
508 AFSFileID stParentFileId;
513 pFileObject = pIrpSp->FileObject;
515 pFcb = (AFSFcb *)pFileObject->FsContext;
516 pCcb = (AFSCcb *)pFileObject->FsContext2;
521 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
522 AFS_TRACE_LEVEL_ERROR,
523 "AFSSetFileInfo Attempted access (%08lX) when pFcb == NULL\n",
526 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
529 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
530 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
536 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
537 AFS_TRACE_LEVEL_VERBOSE,
538 "AFSSetFileInfo Acquiring Fcb lock %08lX EXCL %08lX\n",
539 &pFcb->NPFcb->Resource,
540 PsGetCurrentThread());
542 AFSAcquireExcl( &pFcb->NPFcb->Resource,
548 // Don't allow requests against IOCtl nodes
551 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
554 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
555 AFS_TRACE_LEVEL_ERROR,
556 "AFSSetFileInfo Failing request against PIOCtl Fcb\n");
558 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
560 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
563 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
564 AFS_TRACE_LEVEL_VERBOSE,
565 "AFSSetFileInfo Processing request against SpecialShare Fcb\n");
567 ntStatus = AFSProcessShareSetInfo( Irp,
571 try_return( ntStatus);
574 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
577 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
578 AFS_TRACE_LEVEL_ERROR,
579 "AFSSetFileInfo Request failed due to read only volume\n",
582 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
585 if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB &&
586 FileInformationClass != FileDispositionInformation)
588 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
589 AFS_TRACE_LEVEL_VERBOSE,
590 "AFSSetFileInfo request against Invalid Fcb\n");
592 try_return( ntStatus = STATUS_ACCESS_DENIED);
596 // Ensure rename operations are synchronous
599 if( FileInformationClass == FileRenameInformation)
602 bCanQueueRequest = FALSE;
606 // Store away the parent fid
609 RtlZeroMemory( &stParentFileId,
612 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
614 stParentFileId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
618 // Process the request
621 switch( FileInformationClass)
624 case FileBasicInformation:
627 bUpdateFileInfo = TRUE;
629 ntStatus = AFSSetBasicInfo( Irp,
635 case FileDispositionInformation:
638 ntStatus = AFSSetDispositionInfo( Irp,
644 case FileRenameInformation:
647 ntStatus = AFSSetRenameInfo( Irp);
652 case FilePositionInformation:
655 ntStatus = AFSSetPositionInfo( Irp,
661 case FileLinkInformation:
664 ntStatus = AFSSetFileLinkInfo( Irp);
669 case FileAllocationInformation:
672 ntStatus = AFSSetAllocationInfo( Irp,
678 case FileEndOfFileInformation:
681 ntStatus = AFSSetEndOfFileInfo( Irp,
689 ntStatus = STATUS_INVALID_PARAMETER;
699 AFSReleaseResource( &pFcb->NPFcb->Resource);
702 if( NT_SUCCESS( ntStatus) &&
706 ntStatus = AFSUpdateFileInformation( &stParentFileId,
707 pFcb->ObjectInformation,
710 if( !NT_SUCCESS( ntStatus))
713 AFSAcquireExcl( &pFcb->NPFcb->Resource,
717 // Unwind the update and fail the request
720 AFSUnwindFileInfo( pFcb,
723 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
724 AFS_TRACE_LEVEL_ERROR,
725 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
726 &pCcb->DirectoryCB->NameInformation.FileName,
727 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
728 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
729 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
730 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
733 AFSReleaseResource( &pFcb->NPFcb->Resource);
737 if( !NT_SUCCESS( ntStatus))
741 pCcb->DirectoryCB != NULL)
744 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
745 AFS_TRACE_LEVEL_ERROR,
746 "AFSSetFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
747 &pCcb->DirectoryCB->NameInformation.FileName,
748 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
749 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
750 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
751 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
756 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
761 "EXCEPTION - AFSSetFileInfo\n");
763 AFSDumpTraceFilesFnc();
765 ntStatus = STATUS_UNSUCCESSFUL;
770 AFSReleaseResource( &pFcb->NPFcb->Resource);
774 AFSCompleteRequest( Irp,
781 // Function: AFSQueryBasicInfo
785 // This function is the handler for the query basic information request
789 // A status is returned for the function
793 AFSQueryBasicInfo( IN PIRP Irp,
794 IN AFSDirectoryCB *DirectoryCB,
795 IN OUT PFILE_BASIC_INFORMATION Buffer,
798 NTSTATUS ntStatus = STATUS_SUCCESS;
799 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
800 ULONG ulFileAttribs = 0;
803 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
804 AFSFileInfoCB stFileInfo;
805 AFSDirectoryCB *pParentDirectoryCB = NULL;
806 UNICODE_STRING uniParentPath;
808 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
811 RtlZeroMemory( Buffer,
814 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
816 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
817 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
819 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
822 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
824 AFSRetrieveParentPath( &pCcb->FullFileName,
827 RtlZeroMemory( &stFileInfo,
828 sizeof( AFSFileInfoCB));
831 // Can't hold the Fcb while evaluating the path, leads to lock inversion
834 AFSReleaseResource( &pFcb->NPFcb->Resource);
836 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
844 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
847 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
852 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
855 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
858 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
862 AFSAcquireShared( &pFcb->NPFcb->Resource,
867 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
868 AFS_TRACE_LEVEL_VERBOSE_2,
869 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
870 &pCcb->DirectoryCB->NameInformation.FileName,
871 pCcb->DirectoryCB->ObjectInformation->FileType,
872 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
875 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
876 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
877 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
878 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
879 Buffer->FileAttributes = ulFileAttribs;
881 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
882 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
885 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
887 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
891 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
895 *Length -= sizeof( FILE_BASIC_INFORMATION);
900 ntStatus = STATUS_BUFFER_TOO_SMALL;
907 AFSQueryStandardInfo( IN PIRP Irp,
908 IN AFSDirectoryCB *DirectoryCB,
909 IN OUT PFILE_STANDARD_INFORMATION Buffer,
913 NTSTATUS ntStatus = STATUS_SUCCESS;
916 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
917 AFSFileInfoCB stFileInfo;
918 AFSDirectoryCB *pParentDirectoryCB = NULL;
919 UNICODE_STRING uniParentPath;
920 ULONG ulFileAttribs = 0;
922 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
925 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
926 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
928 RtlZeroMemory( Buffer,
931 Buffer->NumberOfLinks = 1;
932 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
934 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
936 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
938 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
940 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
943 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
945 AFSRetrieveParentPath( &pCcb->FullFileName,
948 RtlZeroMemory( &stFileInfo,
949 sizeof( AFSFileInfoCB));
952 // Can't hold the Fcb while evaluating the path, leads to lock inversion
955 AFSReleaseResource( &pFcb->NPFcb->Resource);
957 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
965 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
968 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
973 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
976 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
979 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
983 AFSAcquireShared( &pFcb->NPFcb->Resource,
987 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
988 AFS_TRACE_LEVEL_VERBOSE_2,
989 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
990 &pCcb->DirectoryCB->NameInformation.FileName,
991 pCcb->DirectoryCB->ObjectInformation->FileType,
992 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
995 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
997 *Length -= sizeof( FILE_STANDARD_INFORMATION);
1002 ntStatus = STATUS_BUFFER_TOO_SMALL;
1009 AFSQueryInternalInfo( IN PIRP Irp,
1011 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
1012 IN OUT PLONG Length)
1015 NTSTATUS ntStatus = STATUS_SUCCESS;
1017 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
1020 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Volume;
1022 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Vnode;
1024 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
1029 ntStatus = STATUS_BUFFER_TOO_SMALL;
1036 AFSQueryEaInfo( IN PIRP Irp,
1037 IN AFSDirectoryCB *DirectoryCB,
1038 IN OUT PFILE_EA_INFORMATION Buffer,
1039 IN OUT PLONG Length)
1042 NTSTATUS ntStatus = STATUS_SUCCESS;
1044 RtlZeroMemory( Buffer,
1047 if( *Length >= sizeof( FILE_EA_INFORMATION))
1052 *Length -= sizeof( FILE_EA_INFORMATION);
1057 ntStatus = STATUS_BUFFER_TOO_SMALL;
1064 AFSQueryPositionInfo( IN PIRP Irp,
1066 IN OUT PFILE_POSITION_INFORMATION Buffer,
1067 IN OUT PLONG Length)
1070 NTSTATUS ntStatus = STATUS_SUCCESS;
1071 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1073 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1076 RtlZeroMemory( Buffer,
1079 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1081 *Length -= sizeof( FILE_POSITION_INFORMATION);
1086 ntStatus = STATUS_BUFFER_TOO_SMALL;
1093 AFSQueryAccess( IN PIRP Irp,
1095 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1096 IN OUT PLONG Length)
1099 NTSTATUS ntStatus = STATUS_SUCCESS;
1101 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1104 RtlZeroMemory( Buffer,
1107 Buffer->AccessFlags = 0;
1109 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1114 ntStatus = STATUS_BUFFER_TOO_SMALL;
1121 AFSQueryMode( IN PIRP Irp,
1123 IN OUT PFILE_MODE_INFORMATION Buffer,
1124 IN OUT PLONG Length)
1127 NTSTATUS ntStatus = STATUS_SUCCESS;
1129 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1132 RtlZeroMemory( Buffer,
1137 *Length -= sizeof( FILE_MODE_INFORMATION);
1142 ntStatus = STATUS_BUFFER_TOO_SMALL;
1149 AFSQueryAlignment( IN PIRP Irp,
1151 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1152 IN OUT PLONG Length)
1155 NTSTATUS ntStatus = STATUS_SUCCESS;
1157 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1160 RtlZeroMemory( Buffer,
1163 Buffer->AlignmentRequirement = 1;
1165 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1170 ntStatus = STATUS_BUFFER_TOO_SMALL;
1177 AFSQueryNameInfo( IN PIRP Irp,
1178 IN AFSDirectoryCB *DirectoryCB,
1179 IN OUT PFILE_NAME_INFORMATION Buffer,
1180 IN OUT PLONG Length)
1183 NTSTATUS ntStatus = STATUS_SUCCESS;
1184 ULONG ulCopyLength = 0;
1185 ULONG cchCopied = 0;
1186 AFSFcb *pFcb = NULL;
1187 AFSCcb *pCcb = NULL;
1188 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1189 BOOLEAN bAddLeadingSlash = FALSE;
1190 BOOLEAN bAddTrailingSlash = FALSE;
1191 USHORT usFullNameLength = 0;
1193 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1195 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1197 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1200 RtlZeroMemory( Buffer,
1203 if( pCcb->FullFileName.Length == 0 ||
1204 pCcb->FullFileName.Buffer[ 0] != L'\\')
1206 bAddLeadingSlash = TRUE;
1209 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1210 pCcb->FullFileName.Length > 0 &&
1211 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1213 bAddTrailingSlash = TRUE;
1216 usFullNameLength = sizeof( WCHAR) +
1217 AFSServerName.Length +
1218 pCcb->FullFileName.Length;
1220 if( bAddLeadingSlash)
1222 usFullNameLength += sizeof( WCHAR);
1225 if( bAddTrailingSlash)
1227 usFullNameLength += sizeof( WCHAR);
1230 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1233 ulCopyLength = (LONG)usFullNameLength;
1238 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1240 ntStatus = STATUS_BUFFER_OVERFLOW;
1243 Buffer->FileNameLength = (ULONG)usFullNameLength;
1245 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1247 if( ulCopyLength > 0)
1250 Buffer->FileName[ 0] = L'\\';
1251 ulCopyLength -= sizeof( WCHAR);
1253 *Length -= sizeof( WCHAR);
1256 if( ulCopyLength >= AFSServerName.Length)
1259 RtlCopyMemory( &Buffer->FileName[ 1],
1260 AFSServerName.Buffer,
1261 AFSServerName.Length);
1263 ulCopyLength -= AFSServerName.Length;
1264 *Length -= AFSServerName.Length;
1265 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1267 if ( ulCopyLength > 0 &&
1271 Buffer->FileName[ cchCopied] = L'\\';
1273 ulCopyLength -= sizeof( WCHAR);
1274 *Length -= sizeof( WCHAR);
1278 if( ulCopyLength >= pCcb->FullFileName.Length)
1281 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1282 pCcb->FullFileName.Buffer,
1283 pCcb->FullFileName.Length);
1285 ulCopyLength -= pCcb->FullFileName.Length;
1286 *Length -= pCcb->FullFileName.Length;
1287 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1289 if( ulCopyLength > 0 &&
1292 Buffer->FileName[ cchCopied] = L'\\';
1294 *Length -= sizeof( WCHAR);
1300 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1301 pCcb->FullFileName.Buffer,
1304 *Length -= ulCopyLength;
1312 ntStatus = STATUS_BUFFER_TOO_SMALL;
1319 AFSQueryShortNameInfo( IN PIRP Irp,
1320 IN AFSDirectoryCB *DirectoryCB,
1321 IN OUT PFILE_NAME_INFORMATION Buffer,
1322 IN OUT PLONG Length)
1325 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1326 ULONG ulCopyLength = 0;
1328 RtlZeroMemory( Buffer,
1331 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1335 // The short name IS the long name
1338 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1341 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1344 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1346 ntStatus = STATUS_SUCCESS;
1351 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1353 ntStatus = STATUS_BUFFER_OVERFLOW;
1356 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1358 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1360 if( ulCopyLength > 0)
1363 RtlCopyMemory( Buffer->FileName,
1364 DirectoryCB->NameInformation.FileName.Buffer,
1367 *Length -= ulCopyLength;
1374 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1377 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1380 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1382 ntStatus = STATUS_SUCCESS;
1387 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1389 ntStatus = STATUS_BUFFER_OVERFLOW;
1392 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1394 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1396 if( ulCopyLength > 0)
1399 RtlCopyMemory( Buffer->FileName,
1400 DirectoryCB->NameInformation.ShortName,
1401 Buffer->FileNameLength);
1403 *Length -= ulCopyLength;
1412 AFSQueryNetworkInfo( IN PIRP Irp,
1413 IN AFSDirectoryCB *DirectoryCB,
1414 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1415 IN OUT PLONG Length)
1418 NTSTATUS ntStatus = STATUS_SUCCESS;
1419 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1420 AFSFcb *pFcb = NULL;
1421 AFSCcb *pCcb = NULL;
1422 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1423 AFSFileInfoCB stFileInfo;
1424 AFSDirectoryCB *pParentDirectoryCB = NULL;
1425 UNICODE_STRING uniParentPath;
1426 ULONG ulFileAttribs = 0;
1428 RtlZeroMemory( Buffer,
1431 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1434 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1436 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1437 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1439 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1442 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1444 AFSRetrieveParentPath( &pCcb->FullFileName,
1447 RtlZeroMemory( &stFileInfo,
1448 sizeof( AFSFileInfoCB));
1451 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1454 AFSReleaseResource( &pFcb->NPFcb->Resource);
1456 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1464 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1467 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1472 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1475 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1478 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1482 AFSAcquireShared( &pFcb->NPFcb->Resource,
1486 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1487 AFS_TRACE_LEVEL_VERBOSE_2,
1488 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1489 &pCcb->DirectoryCB->NameInformation.FileName,
1490 pCcb->DirectoryCB->ObjectInformation->FileType,
1491 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1494 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1495 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1496 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1497 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1499 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1500 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1502 Buffer->FileAttributes = ulFileAttribs;
1504 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1505 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1508 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1511 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1516 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1520 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1525 ntStatus = STATUS_BUFFER_TOO_SMALL;
1532 AFSQueryStreamInfo( IN PIRP Irp,
1533 IN AFSDirectoryCB *DirectoryCB,
1534 IN OUT FILE_STREAM_INFORMATION *Buffer,
1535 IN OUT PLONG Length)
1538 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1539 ULONG ulCopyLength = 0;
1540 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1542 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1545 RtlZeroMemory( Buffer,
1548 Buffer->NextEntryOffset = 0;
1551 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1554 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1559 ntStatus = STATUS_SUCCESS;
1564 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1566 ntStatus = STATUS_BUFFER_OVERFLOW;
1569 Buffer->StreamNameLength = 14; // ::$DATA
1571 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1573 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1575 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1577 if( ulCopyLength > 0)
1580 RtlCopyMemory( Buffer->StreamName,
1584 *Length -= ulCopyLength;
1590 Buffer->StreamNameLength = 0; // No stream for a directory
1592 // The response size is zero
1594 ntStatus = STATUS_SUCCESS;
1602 AFSQueryAttribTagInfo( IN PIRP Irp,
1603 IN AFSDirectoryCB *DirectoryCB,
1604 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1605 IN OUT PLONG Length)
1608 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1609 ULONG ulCopyLength = 0;
1610 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1611 AFSFcb *pFcb = NULL;
1612 AFSCcb *pCcb = NULL;
1613 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1614 AFSFileInfoCB stFileInfo;
1615 AFSDirectoryCB *pParentDirectoryCB = NULL;
1616 UNICODE_STRING uniParentPath;
1617 ULONG ulFileAttribs = 0;
1619 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1622 RtlZeroMemory( Buffer,
1625 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1627 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1628 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1630 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1633 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1635 AFSRetrieveParentPath( &pCcb->FullFileName,
1638 RtlZeroMemory( &stFileInfo,
1639 sizeof( AFSFileInfoCB));
1642 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1645 AFSReleaseResource( &pFcb->NPFcb->Resource);
1647 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1655 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1658 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1663 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1666 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1669 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1673 AFSAcquireShared( &pFcb->NPFcb->Resource,
1677 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1678 AFS_TRACE_LEVEL_VERBOSE_2,
1679 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1680 &pCcb->DirectoryCB->NameInformation.FileName,
1681 pCcb->DirectoryCB->ObjectInformation->FileType,
1682 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1685 Buffer->FileAttributes = ulFileAttribs;
1687 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1688 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1691 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1694 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1699 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1703 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1705 Buffer->ReparseTag = IO_REPARSE_TAG_SURROGATE|IO_REPARSE_TAG_OPENAFS_DFS;
1708 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1710 ntStatus = STATUS_SUCCESS;
1717 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1718 IN AFSDirectoryCB *DirectoryCB,
1719 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1720 IN OUT PLONG Length)
1723 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1724 ULONG ulCopyLength = 0;
1725 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1727 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1730 RtlZeroMemory( Buffer,
1733 Buffer->StructureVersion = 1;
1735 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1737 Buffer->Protocol = WNNC_NET_OPENAFS;
1739 Buffer->ProtocolMajorVersion = 3;
1741 Buffer->ProtocolMinorVersion = 0;
1743 Buffer->ProtocolRevision = 0;
1745 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1747 ntStatus = STATUS_SUCCESS;
1754 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1755 IN AFSDirectoryCB *DirectoryCB,
1756 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1757 IN OUT PLONG Length)
1760 NTSTATUS ntStatus = STATUS_SUCCESS;
1761 ULONG ulCopyLength = 0;
1762 ULONG cchCopied = 0;
1763 AFSFcb *pFcb = NULL;
1764 AFSCcb *pCcb = NULL;
1765 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1766 BOOLEAN bAddLeadingSlash = FALSE;
1767 USHORT usFullNameLength = 0;
1769 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1771 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1773 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1776 RtlZeroMemory( Buffer,
1779 if( pCcb->FullFileName.Length == 0 ||
1780 pCcb->FullFileName.Buffer[ 0] != L'\\')
1782 bAddLeadingSlash = TRUE;
1785 usFullNameLength = pCcb->FullFileName.Length;
1787 if( bAddLeadingSlash)
1789 usFullNameLength += sizeof( WCHAR);
1792 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1794 ulCopyLength = (LONG)usFullNameLength;
1799 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1801 ntStatus = STATUS_BUFFER_OVERFLOW;
1804 Buffer->FileNameLength = (ULONG)usFullNameLength;
1806 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1808 if( ulCopyLength > 0)
1811 if( bAddLeadingSlash)
1814 Buffer->FileName[ cchCopied] = L'\\';
1816 ulCopyLength -= sizeof( WCHAR);
1817 *Length -= sizeof( WCHAR);
1821 if( ulCopyLength >= pCcb->FullFileName.Length)
1824 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1825 pCcb->FullFileName.Buffer,
1826 pCcb->FullFileName.Length);
1828 ulCopyLength -= pCcb->FullFileName.Length;
1829 *Length -= pCcb->FullFileName.Length;
1830 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1835 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1836 pCcb->FullFileName.Buffer,
1839 *Length -= ulCopyLength;
1846 ntStatus = STATUS_BUFFER_TOO_SMALL;
1853 AFSSetBasicInfo( IN PIRP Irp,
1854 IN AFSDirectoryCB *DirectoryCB)
1856 NTSTATUS ntStatus = STATUS_SUCCESS;
1857 PFILE_BASIC_INFORMATION pBuffer;
1858 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1859 ULONG ulNotifyFilter = 0;
1860 AFSCcb *pCcb = NULL;
1865 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1867 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1869 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1871 if( pBuffer->FileAttributes != (ULONGLONG)0)
1874 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1875 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1878 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1881 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1884 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1887 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1889 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1891 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1893 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1896 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1898 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1899 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1902 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1904 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1906 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1908 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1911 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1913 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1914 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1917 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1919 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1921 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1923 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1926 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1928 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1929 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1932 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1934 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1936 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1938 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1941 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1943 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1944 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1947 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1949 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
1951 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1953 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1956 if( ulNotifyFilter > 0)
1959 if( DirectoryCB->ObjectInformation->ParentObjectInformation != NULL)
1962 AFSFsRtlNotifyFullReportChange( DirectoryCB->ObjectInformation->ParentObjectInformation,
1964 (ULONG)ulNotifyFilter,
1965 (ULONG)FILE_ACTION_MODIFIED);
1978 AFSSetDispositionInfo( IN PIRP Irp,
1979 IN AFSDirectoryCB *DirectoryCB)
1981 NTSTATUS ntStatus = STATUS_SUCCESS;
1982 PFILE_DISPOSITION_INFORMATION pBuffer;
1983 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1984 AFSFcb *pFcb = NULL;
1985 AFSCcb *pCcb = NULL;
1990 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1992 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1994 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1997 // Can't delete the root
2000 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2003 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2004 AFS_TRACE_LEVEL_ERROR,
2005 "AFSSetDispositionInfo Attempt to delete root entry\n");
2007 try_return( ntStatus = STATUS_CANNOT_DELETE);
2011 // If the file is read only then do not allow the delete
2014 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
2017 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2018 AFS_TRACE_LEVEL_ERROR,
2019 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
2020 &DirectoryCB->NameInformation.FileName);
2022 try_return( ntStatus = STATUS_CANNOT_DELETE);
2025 if( pBuffer->DeleteFile)
2029 // Check if the caller can delete the file
2032 ntStatus = AFSNotifyDelete( DirectoryCB,
2036 if( !NT_SUCCESS( ntStatus))
2039 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2040 AFS_TRACE_LEVEL_ERROR,
2041 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
2042 &DirectoryCB->NameInformation.FileName,
2045 try_return( ntStatus);
2048 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2052 // Reduce the Link count in the object information block
2053 // to correspond with the deletion of the directory entry.
2056 pFcb->ObjectInformation->Links--;
2059 // Check if this is a directory that there are not currently other opens
2062 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2065 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2066 AFS_TRACE_LEVEL_ERROR,
2067 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
2068 &DirectoryCB->NameInformation.FileName,
2069 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount);
2071 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2074 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2077 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2078 AFS_TRACE_LEVEL_ERROR,
2079 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2080 &DirectoryCB->NameInformation.FileName);
2082 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2085 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2086 AFS_TRACE_LEVEL_VERBOSE,
2087 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2089 &DirectoryCB->NameInformation.FileName);
2091 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2093 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2096 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2097 AFS_TRACE_LEVEL_VERBOSE,
2098 "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
2099 &pFcb->NPFcb->SectionObjectResource,
2100 PsGetCurrentThread());
2102 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
2106 // Attempt to flush any outstanding data
2109 if( !MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2113 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2114 AFS_TRACE_LEVEL_ERROR,
2115 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2116 &DirectoryCB->NameInformation.FileName);
2118 try_return( ntStatus = STATUS_CANNOT_DELETE);
2122 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2123 // deadlock with Trend Micro's Enterprise anti-virus product
2124 // which attempts to open the file which is being deleted.
2127 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2128 AFS_TRACE_LEVEL_VERBOSE,
2129 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2131 &DirectoryCB->NameInformation.FileName);
2133 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2136 // Purge the cache as well
2139 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2142 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2148 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2152 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2153 AFS_TRACE_LEVEL_VERBOSE,
2154 "AFSSetDispositionInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
2155 &pFcb->NPFcb->SectionObjectResource,
2156 PsGetCurrentThread());
2158 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
2164 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2168 // OK, should be good to go, set the flag in the file object
2171 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2182 AFSSetFileLinkInfo( IN PIRP Irp)
2185 NTSTATUS ntStatus = STATUS_SUCCESS;
2186 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2187 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2188 IO_STATUS_BLOCK stIoSb = {0,0};
2189 PFILE_LINK_INFORMATION pFileLinkInfo = NULL;
2190 PFILE_OBJECT pSrcFileObj = NULL;
2191 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2192 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2193 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2194 AFSObjectInfoCB *pSrcObject = NULL, *pTargetObject = NULL;
2195 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2196 UNICODE_STRING uniSourceName, uniTargetName;
2197 UNICODE_STRING uniFullTargetName, uniTargetParentName;
2198 UNICODE_STRING uniShortName;
2199 BOOLEAN bCommonParent = FALSE;
2200 AFSDirectoryCB *pTargetDirEntry = NULL;
2201 AFSDirectoryCB *pNewTargetDirEntry = NULL;
2203 BOOLEAN bTargetEntryExists = FALSE;
2205 BOOLEAN bReleaseTargetDirLock = FALSE;
2207 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2212 pSrcFileObj = pIrpSp->FileObject;
2214 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2215 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2217 pSrcObject = pSrcFcb->ObjectInformation;
2218 pSrcParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2220 pFileLinkInfo = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2223 // Perform some basic checks to ensure FS integrity
2226 if( pSrcFcb->Header.NodeTypeCode != AFS_FILE_FCB)
2229 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2230 AFS_TRACE_LEVEL_ERROR,
2231 "AFSSetFileLinkInfo Attempt to non-file (INVALID_PARAMETER)\n");
2233 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2236 if( pTargetFileObj == NULL)
2239 if ( pFileLinkInfo->RootDirectory)
2243 // The target directory is provided by HANDLE
2244 // RootDirectory is only set when the target directory is not the same
2245 // as the source directory.
2247 // AFS only supports hard links within a single directory.
2249 // The IOManager should translate any Handle to a FileObject for us.
2250 // However, the failure to receive a FileObject is treated as a fatal
2254 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2255 AFS_TRACE_LEVEL_ERROR,
2256 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory by handle INVALID_PARAMETER\n",
2257 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2259 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2264 uniFullTargetName.Length = (USHORT)pFileLinkInfo->FileNameLength;
2266 uniFullTargetName.Buffer = (PWSTR)&pFileLinkInfo->FileName;
2268 AFSRetrieveFinalComponent( &uniFullTargetName,
2271 AFSRetrieveParentPath( &uniFullTargetName,
2272 &uniTargetParentName);
2274 if ( uniTargetParentName.Length == 0)
2278 // This is a simple rename. Here the target directory is the same as the source parent directory
2279 // and the name is retrieved from the system buffer information
2282 pTargetParentObject = pSrcParentObject;
2287 // uniTargetParentName contains the directory the renamed object
2288 // will be moved to. Must obtain the TargetParentObject.
2291 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2292 AFS_TRACE_LEVEL_ERROR,
2293 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory %wZ (NOT_SAME_DEVICE)\n",
2294 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2295 &uniFullTargetName);
2297 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2301 pTargetDcb = pTargetParentObject->Fcb;
2307 // So here we have the target directory taken from the targetfile object
2310 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2312 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2314 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2317 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2318 // it is only the target component of the rename operation
2321 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2325 // The quick check to see if they are self linking.
2326 // Do the names match? Only do this where the parent directories are
2330 if( pTargetParentObject == pSrcParentObject)
2333 if( FsRtlAreNamesEqual( &uniTargetName,
2338 try_return( ntStatus = STATUS_SUCCESS);
2341 bCommonParent = TRUE;
2347 // We do not allow cross-volume hard links
2350 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2353 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2354 AFS_TRACE_LEVEL_ERROR,
2355 "AFSSetFileLinkInfo Attempt to link to different volume %wZ\n",
2356 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2358 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2362 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2365 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2368 bReleaseTargetDirLock = TRUE;
2370 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2374 if( pTargetDirEntry == NULL)
2378 // Missed so perform a case insensitive lookup
2381 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2384 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2389 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2390 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2395 // Try the short name
2397 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2403 // Increment our ref count on the dir entry
2406 if( pTargetDirEntry != NULL)
2409 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2411 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2413 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2414 AFS_TRACE_LEVEL_VERBOSE,
2415 "AFSSetFileLinkInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2416 &pTargetDirEntry->NameInformation.FileName,
2421 ASSERT( lCount >= 0);
2423 if( !pFileLinkInfo->ReplaceIfExists)
2426 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2427 AFS_TRACE_LEVEL_ERROR,
2428 "AFSSetFileLinkInfo Attempt to link with target collision %wZ Target %wZ\n",
2429 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2430 &pTargetDirEntry->NameInformation.FileName);
2432 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2435 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2436 AFS_TRACE_LEVEL_ERROR,
2437 "AFSSetFileLinkInfo Target %wZ exists DE %p Count %08lX, performing delete of target\n",
2438 &pTargetDirEntry->NameInformation.FileName,
2440 pTargetDirEntry->DirOpenReferenceCount);
2443 // Pull the directory entry from the parent
2446 AFSRemoveDirNodeFromParent( pTargetParentObject,
2450 bTargetEntryExists = TRUE;
2454 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2455 AFS_TRACE_LEVEL_VERBOSE,
2456 "AFSSetFileLinkInfo Target does NOT exist, normal linking\n");
2460 // OK, this is a simple rename. Issue the rename
2461 // request to the service.
2464 ntStatus = AFSNotifyHardLink( pSrcFcb->ObjectInformation,
2465 &pSrcCcb->AuthGroup,
2466 pSrcFcb->ObjectInformation->ParentObjectInformation,
2467 pTargetDcb->ObjectInformation,
2468 pSrcCcb->DirectoryCB,
2470 pFileLinkInfo->ReplaceIfExists,
2471 &pNewTargetDirEntry);
2473 if( !NT_SUCCESS( ntStatus))
2476 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2477 AFS_TRACE_LEVEL_ERROR,
2478 "AFSSetFileLinkInfo Failed link of %wZ to target %wZ Status %08lX\n",
2479 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2483 try_return( ntStatus);
2486 AFSInsertDirectoryNode( pTargetDcb->ObjectInformation,
2491 // Send notification for the target link file
2494 if( bTargetEntryExists || pNewTargetDirEntry)
2497 ulNotificationAction = FILE_ACTION_MODIFIED;
2502 ulNotificationAction = FILE_ACTION_ADDED;
2505 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
2507 (ULONG)ulNotifyFilter,
2508 (ULONG)ulNotificationAction);
2512 if( !NT_SUCCESS( ntStatus))
2515 if( bTargetEntryExists)
2518 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
2524 if( pTargetDirEntry != NULL)
2527 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
2529 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2530 AFS_TRACE_LEVEL_VERBOSE,
2531 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2532 &pTargetDirEntry->NameInformation.FileName,
2537 ASSERT( lCount >= 0);
2540 if( bReleaseTargetDirLock)
2543 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2551 AFSSetRenameInfo( IN PIRP Irp)
2554 NTSTATUS ntStatus = STATUS_SUCCESS;
2555 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2556 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2557 IO_STATUS_BLOCK stIoSb = {0,0};
2558 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2559 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2560 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2561 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2562 PFILE_OBJECT pTargetParentFileObj = NULL;
2563 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2564 UNICODE_STRING uniTargetName, uniSourceName, uniTargetParentName;
2565 BOOLEAN bReplaceIfExists = FALSE;
2566 UNICODE_STRING uniShortName;
2567 AFSDirectoryCB *pTargetDirEntry = NULL;
2568 ULONG ulTargetCRC = 0;
2569 BOOLEAN bTargetEntryExists = FALSE;
2570 AFSObjectInfoCB *pSrcObject = NULL, *pTargetObject = NULL;
2571 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2572 AFSFileID stNewFid, stTmpTargetFid;
2573 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2574 UNICODE_STRING uniFullTargetName;
2575 BOOLEAN bCommonParent = FALSE;
2576 BOOLEAN bReleaseTargetDirLock = FALSE;
2577 BOOLEAN bReleaseSourceDirLock = FALSE;
2578 BOOLEAN bDereferenceTargetParentObject = FALSE;
2579 PERESOURCE pSourceDirLock = NULL;
2585 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2587 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2589 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2590 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2592 pSrcObject = pSrcFcb->ObjectInformation;
2593 pSrcParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2596 // Perform some basic checks to ensure FS integrity
2599 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2603 // Can't rename the root directory
2606 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2607 AFS_TRACE_LEVEL_ERROR,
2608 "AFSSetRenameInfo Attempt to rename root entry\n");
2610 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2613 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2617 // If there are any open children then fail the rename
2620 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2623 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2624 AFS_TRACE_LEVEL_ERROR,
2625 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2626 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2628 try_return( ntStatus = STATUS_ACCESS_DENIED);
2634 // Extract off the final component name from the Fcb
2637 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2638 uniSourceName.MaximumLength = uniSourceName.Length;
2640 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2643 // Resolve the target fileobject
2646 if( pTargetFileObj == NULL)
2649 if ( pRenameInfo->RootDirectory)
2652 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2653 AFS_TRACE_LEVEL_ERROR,
2654 "AFSSetRenameInfo Handle provided but no FileObject ntStatus INVALID_PARAMETER\n");
2656 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2661 uniFullTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2663 uniFullTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2665 AFSRetrieveFinalComponent( &uniFullTargetName,
2668 AFSRetrieveParentPath( &uniFullTargetName,
2669 &uniTargetParentName);
2671 if ( uniTargetParentName.Length == 0)
2675 // This is a simple rename. Here the target directory is the same as the source parent directory
2676 // and the name is retrieved from the system buffer information
2679 pTargetParentObject = pSrcParentObject;
2684 // uniTargetParentName contains the directory the renamed object
2685 // will be moved to. Must obtain the TargetParentObject.
2688 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2689 AFS_TRACE_LEVEL_ERROR,
2690 "AFSSetRenameInfo Attempt to move %wZ to %wZ -- not yet supported (NOT_SAME_DEVICE)\n",
2691 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2692 &uniFullTargetName);
2694 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2698 pTargetDcb = pTargetParentObject->Fcb;
2704 // So here we have the target directory taken from the targetfile object
2707 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2709 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2711 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2714 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2715 // it is only the target component of the rename operation
2718 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2722 // The quick check to see if they are not really performing a rename
2723 // Do the names match? Only do this where the parent directories are
2727 if( pTargetParentObject == pSrcParentObject)
2730 if( FsRtlAreNamesEqual( &uniTargetName,
2735 try_return( ntStatus = STATUS_SUCCESS);
2738 bCommonParent = TRUE;
2743 bCommonParent = FALSE;
2747 // We do not allow cross-volume renames to occur
2750 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2753 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2754 AFS_TRACE_LEVEL_ERROR,
2755 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2756 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2758 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2761 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2764 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2767 bReleaseTargetDirLock = TRUE;
2769 if( pTargetParentObject != pSrcParentObject)
2771 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2774 bReleaseSourceDirLock = TRUE;
2776 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2779 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2783 if( pTargetDirEntry == NULL)
2787 // Missed so perform a case insensitive lookup
2790 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2793 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2798 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2799 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2804 // Try the short name
2806 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2812 // Increment our ref count on the dir entry
2815 if( pTargetDirEntry != NULL)
2818 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2820 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2823 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2824 AFS_TRACE_LEVEL_VERBOSE,
2825 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2826 &pTargetDirEntry->NameInformation.FileName,
2831 ASSERT( lCount >= 0);
2833 if( !bReplaceIfExists)
2836 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2837 AFS_TRACE_LEVEL_ERROR,
2838 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2839 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2840 &pTargetDirEntry->NameInformation.FileName);
2842 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2845 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2846 AFS_TRACE_LEVEL_ERROR,
2847 "AFSSetRenameInfo Target %wZ exists DE %p Count %08lX, performing delete of target\n",
2848 &pTargetDirEntry->NameInformation.FileName,
2850 pTargetDirEntry->DirOpenReferenceCount);
2853 // Pull the directory entry from the parent
2856 AFSRemoveDirNodeFromParent( pTargetParentObject,
2860 bTargetEntryExists = TRUE;
2864 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2865 AFS_TRACE_LEVEL_VERBOSE,
2866 "AFSSetRenameInfo Target does NOT exist, normal rename\n");
2870 // We need to remove the DirEntry from the parent node, update the index
2871 // and reinsert it into the parent tree. Note that for entries with the
2872 // same parent we do not pull the node from the enumeration list
2875 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2876 pSrcCcb->DirectoryCB,
2880 // OK, this is a simple rename. Issue the rename
2881 // request to the service.
2884 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2885 &pSrcCcb->AuthGroup,
2886 pSrcFcb->ObjectInformation->ParentObjectInformation,
2887 pTargetDcb->ObjectInformation,
2888 pSrcCcb->DirectoryCB,
2892 if( !NT_SUCCESS( ntStatus))
2896 // Attempt to re-insert the directory entry
2899 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2900 pSrcCcb->DirectoryCB,
2903 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2904 AFS_TRACE_LEVEL_ERROR,
2905 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2906 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2910 try_return( ntStatus);
2914 // Set the notification up for the source file
2917 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2918 !bTargetEntryExists)
2921 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2926 ulNotificationAction = FILE_ACTION_REMOVED;
2929 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2932 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2937 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2940 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2942 (ULONG)ulNotifyFilter,
2943 (ULONG)ulNotificationAction);
2946 // Update the name in the dir entry.
2949 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
2952 if( !NT_SUCCESS( ntStatus))
2956 // Attempt to re-insert the directory entry
2959 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2960 pSrcCcb->DirectoryCB,
2963 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2964 AFS_TRACE_LEVEL_ERROR,
2965 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
2966 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2970 try_return( ntStatus);
2974 // Update the object information block, if needed
2977 if( !AFSIsEqualFID( &pSrcObject->FileId,
2981 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
2985 // Remove the old information entry
2988 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2989 &pSrcObject->TreeEntry);
2991 RtlCopyMemory( &pSrcObject->FileId,
2993 sizeof( AFSFileID));
2996 // Insert the entry into the new object table.
2999 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3001 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3004 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3009 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3010 &pSrcObject->TreeEntry)))
3014 // Lost a race, an ObjectInfo object already exists for this FID.
3015 // Let this copy be garbage collected.
3018 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3022 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3026 // Update the hash values for the name trees.
3029 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3032 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3035 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3036 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3037 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3042 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3043 uniShortName.MaximumLength = uniShortName.Length;
3044 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3046 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3049 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3050 AFS_TRACE_LEVEL_VERBOSE,
3051 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3053 &pSrcCcb->DirectoryCB->NameInformation.FileName);
3058 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3065 // Update the file index for the object in the new parent
3068 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3072 // Re-insert the directory entry
3075 AFSInsertDirectoryNode( pTargetParentObject,
3076 pSrcCcb->DirectoryCB,
3080 // Update the parent pointer in the source object if they are different
3083 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
3086 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
3088 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
3090 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3092 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3094 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
3096 ulNotificationAction = FILE_ACTION_ADDED;
3101 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3105 // Now update the notification for the target file
3108 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
3110 (ULONG)ulNotifyFilter,
3111 (ULONG)ulNotificationAction);
3114 // If we performed the rename of the target because it existed, we now need to
3115 // delete the tmp target we created above
3118 if( bTargetEntryExists)
3121 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3122 AFS_TRACE_LEVEL_VERBOSE,
3123 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3125 &pTargetDirEntry->NameInformation.FileName);
3127 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3130 // Try and purge the cache map if this is a file
3133 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3134 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3135 pTargetDirEntry->DirOpenReferenceCount > 1)
3138 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3140 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3141 AFS_TRACE_LEVEL_VERBOSE,
3142 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
3143 &pTargetFcb->NPFcb->SectionObjectResource,
3144 PsGetCurrentThread());
3146 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3150 // Close the section in the event it was mapped
3153 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3157 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3158 AFS_TRACE_LEVEL_ERROR,
3159 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3160 &pTargetDirEntry->NameInformation.FileName);
3163 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3164 AFS_TRACE_LEVEL_VERBOSE,
3165 "AFSSetRenameInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
3166 &pTargetFcb->NPFcb->SectionObjectResource,
3167 PsGetCurrentThread());
3169 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3172 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3174 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3176 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3177 AFS_TRACE_LEVEL_VERBOSE,
3178 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3179 &pTargetDirEntry->NameInformation.FileName,
3184 ASSERT( lCount >= 0);
3189 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3190 AFS_TRACE_LEVEL_VERBOSE,
3191 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3193 &pTargetDirEntry->NameInformation.FileName);
3195 AFSDeleteDirEntry( pTargetParentObject,
3199 pTargetDirEntry = NULL;
3204 if( !NT_SUCCESS( ntStatus))
3207 if( bTargetEntryExists)
3209 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
3215 if( pTargetDirEntry != NULL)
3218 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3220 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3221 AFS_TRACE_LEVEL_VERBOSE,
3222 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3223 &pTargetDirEntry->NameInformation.FileName,
3228 ASSERT( lCount >= 0);
3231 if( bReleaseTargetDirLock)
3233 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3236 if( bReleaseSourceDirLock)
3238 AFSReleaseResource( pSourceDirLock);
3242 if ( bDereferenceTargetParentObject)
3245 ObDereferenceObject( pTargetParentFileObj);
3252 AFSSetPositionInfo( IN PIRP Irp,
3253 IN AFSDirectoryCB *DirectoryCB)
3255 NTSTATUS ntStatus = STATUS_SUCCESS;
3256 PFILE_POSITION_INFORMATION pBuffer;
3257 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3259 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3261 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3267 AFSSetAllocationInfo( IN PIRP Irp,
3268 IN AFSDirectoryCB *DirectoryCB)
3270 NTSTATUS ntStatus = STATUS_SUCCESS;
3271 PFILE_ALLOCATION_INFORMATION pBuffer;
3272 BOOLEAN bReleasePaging = FALSE;
3273 BOOLEAN bTellCc = FALSE;
3274 BOOLEAN bTellService = FALSE;
3275 BOOLEAN bUserMapped = FALSE;
3276 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3277 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3278 AFSFcb *pFcb = NULL;
3279 AFSCcb *pCcb = NULL;
3280 LARGE_INTEGER liSaveAlloc;
3281 LARGE_INTEGER liSaveFileSize;
3282 LARGE_INTEGER liSaveVDL;
3284 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3286 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3288 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3291 // save values to put back
3293 liSaveAlloc = pFcb->Header.AllocationSize;
3294 liSaveFileSize = pFcb->Header.FileSize;
3295 liSaveVDL = pFcb->Header.ValidDataLength;
3297 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3298 pIrpSp->Parameters.SetFile.AdvanceOnly)
3300 return STATUS_SUCCESS ;
3303 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3306 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3307 AFS_TRACE_LEVEL_VERBOSE,
3308 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
3309 &pFcb->NPFcb->SectionObjectResource,
3310 PsGetCurrentThread());
3312 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3315 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3316 &pBuffer->AllocationSize);
3318 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3319 AFS_TRACE_LEVEL_VERBOSE,
3320 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
3321 &pFcb->NPFcb->SectionObjectResource,
3322 PsGetCurrentThread());
3324 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3327 // Truncating the file
3332 ntStatus = STATUS_USER_MAPPED_FILE ;
3338 // If this is a truncation we need to grab the paging IO resource.
3341 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3342 AFS_TRACE_LEVEL_VERBOSE,
3343 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
3344 &pFcb->NPFcb->PagingResource,
3345 PsGetCurrentThread());
3347 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3350 bReleasePaging = TRUE;
3353 // Must drop the Fcb Resource. When changing the file size
3354 // a deadlock can occur with Trend Micro's filter if the file
3355 // size is set to zero.
3358 AFSReleaseResource( &pFcb->NPFcb->Resource);
3360 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3362 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3365 // Tell Cc that Allocation is moved.
3369 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3372 // We are pulling the EOF back as well so we need to tell
3375 bTellService = TRUE;
3377 pFcb->Header.FileSize = pBuffer->AllocationSize;
3379 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3387 // Tell Cc if allocation is increased.
3390 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3391 AFS_TRACE_LEVEL_VERBOSE,
3392 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
3393 &pFcb->NPFcb->PagingResource,
3394 PsGetCurrentThread());
3396 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3399 bReleasePaging = TRUE;
3402 // Must drop the Fcb Resource. When changing the file size
3403 // a deadlock can occur with Trend Micro's filter if the file
3404 // size is set to zero.
3407 AFSReleaseResource( &pFcb->NPFcb->Resource);
3409 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3411 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3413 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3417 // Now Tell the server if we have to
3421 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3422 pFcb->ObjectInformation,
3426 if (NT_SUCCESS(ntStatus))
3429 // Trim extents if we told the service - the update has done an implicit
3430 // trim at the service.
3434 AFSTrimExtents( pFcb,
3435 &pFcb->Header.FileSize);
3438 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3440 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3443 CcIsFileCached( pFileObject))
3445 CcSetFileSizes( pFileObject,
3446 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3452 // Put the saved values back
3454 pFcb->Header.ValidDataLength = liSaveVDL;
3455 pFcb->Header.FileSize = liSaveFileSize;
3456 pFcb->Header.AllocationSize = liSaveAlloc;
3457 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3458 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3464 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3466 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3474 AFSSetEndOfFileInfo( IN PIRP Irp,
3475 IN AFSDirectoryCB *DirectoryCB)
3477 NTSTATUS ntStatus = STATUS_SUCCESS;
3478 PFILE_END_OF_FILE_INFORMATION pBuffer;
3479 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3480 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3481 LARGE_INTEGER liSaveSize;
3482 LARGE_INTEGER liSaveVDL;
3483 LARGE_INTEGER liSaveAlloc;
3484 BOOLEAN bModified = FALSE;
3485 BOOLEAN bReleasePaging = FALSE;
3486 BOOLEAN bTruncated = FALSE;
3487 BOOLEAN bUserMapped = FALSE;
3488 AFSFcb *pFcb = NULL;
3489 AFSCcb *pCcb = NULL;
3491 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3493 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3495 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3497 liSaveSize = pFcb->Header.FileSize;
3498 liSaveAlloc = pFcb->Header.AllocationSize;
3499 liSaveVDL = pFcb->Header.ValidDataLength;
3501 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3502 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3505 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3508 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3509 AFS_TRACE_LEVEL_VERBOSE,
3510 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
3511 &pFcb->NPFcb->SectionObjectResource,
3512 PsGetCurrentThread());
3514 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3517 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3518 &pBuffer->EndOfFile);
3520 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3521 AFS_TRACE_LEVEL_VERBOSE,
3522 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
3523 &pFcb->NPFcb->SectionObjectResource,
3524 PsGetCurrentThread());
3526 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3528 // Truncating the file
3532 ntStatus = STATUS_USER_MAPPED_FILE;
3538 // If this is a truncation we need to grab the paging
3541 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3542 AFS_TRACE_LEVEL_VERBOSE,
3543 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
3544 &pFcb->NPFcb->PagingResource,
3545 PsGetCurrentThread());
3547 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3550 bReleasePaging = TRUE;
3553 // Must drop the Fcb Resource. When changing the file size
3554 // a deadlock can occur with Trend Micro's filter if the file
3555 // size is set to zero.
3558 AFSReleaseResource( &pFcb->NPFcb->Resource);
3560 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3562 pFcb->Header.FileSize = pBuffer->EndOfFile;
3564 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3566 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3568 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3571 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3583 // extending the file, move EOF
3587 // If this is a truncation we need to grab the paging
3590 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3591 AFS_TRACE_LEVEL_VERBOSE,
3592 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
3593 &pFcb->NPFcb->PagingResource,
3594 PsGetCurrentThread());
3596 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3599 bReleasePaging = TRUE;
3602 // Must drop the Fcb Resource. When changing the file size
3603 // a deadlock can occur with Trend Micro's filter if the file
3604 // size is set to zero.
3607 AFSReleaseResource( &pFcb->NPFcb->Resource);
3609 pFcb->Header.FileSize = pBuffer->EndOfFile;
3611 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3613 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3616 // And Allocation as needed.
3618 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3620 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3630 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3632 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3638 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3639 pFcb->ObjectInformation,
3642 if( NT_SUCCESS(ntStatus))
3645 // We are now good to go so tell CC.
3647 CcSetFileSizes( pFileObject,
3648 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3651 // And give up those extents
3656 AFSTrimExtents( pFcb,
3657 &pFcb->Header.FileSize);
3662 pFcb->Header.ValidDataLength = liSaveVDL;
3663 pFcb->Header.FileSize = liSaveSize;
3664 pFcb->Header.AllocationSize = liSaveAlloc;
3665 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3666 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3673 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3675 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3683 AFSProcessShareSetInfo( IN IRP *Irp,
3688 NTSTATUS ntStatus = STATUS_SUCCESS;
3689 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3690 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3691 FILE_INFORMATION_CLASS ulFileInformationClass;
3692 void *pPipeInfo = NULL;
3696 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3698 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3699 AFS_TRACE_LEVEL_VERBOSE,
3700 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3701 &Ccb->DirectoryCB->NameInformation.FileName,
3702 ulFileInformationClass);
3704 pPipeInfo = AFSLockSystemBuffer( Irp,
3705 pIrpSp->Parameters.SetFile.Length);
3707 if( pPipeInfo == NULL)
3710 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3711 AFS_TRACE_LEVEL_ERROR,
3712 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3713 &Ccb->DirectoryCB->NameInformation.FileName);
3715 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3719 // Send the request to the service
3722 ntStatus = AFSNotifySetPipeInfo( Ccb,
3723 (ULONG)ulFileInformationClass,
3724 pIrpSp->Parameters.SetFile.Length,
3727 if( !NT_SUCCESS( ntStatus))
3730 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3731 AFS_TRACE_LEVEL_ERROR,
3732 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3733 &Ccb->DirectoryCB->NameInformation.FileName,
3736 try_return( ntStatus);
3739 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3740 AFS_TRACE_LEVEL_VERBOSE,
3741 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3742 &Ccb->DirectoryCB->NameInformation.FileName,
3743 ulFileInformationClass);
3754 AFSProcessShareQueryInfo( IN IRP *Irp,
3759 NTSTATUS ntStatus = STATUS_SUCCESS;
3760 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3761 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3762 FILE_INFORMATION_CLASS ulFileInformationClass;
3763 void *pPipeInfo = NULL;
3768 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3770 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3771 AFS_TRACE_LEVEL_VERBOSE,
3772 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3773 &Ccb->DirectoryCB->NameInformation.FileName,
3774 ulFileInformationClass);
3776 pPipeInfo = AFSLockSystemBuffer( Irp,
3777 pIrpSp->Parameters.QueryFile.Length);
3779 if( pPipeInfo == NULL)
3782 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3783 AFS_TRACE_LEVEL_ERROR,
3784 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3785 &Ccb->DirectoryCB->NameInformation.FileName);
3787 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3791 // Send the request to the service
3794 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3795 (ULONG)ulFileInformationClass,
3796 pIrpSp->Parameters.QueryFile.Length,
3798 (ULONG *)&Irp->IoStatus.Information);
3800 if( !NT_SUCCESS( ntStatus))
3803 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3804 AFS_TRACE_LEVEL_ERROR,
3805 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3806 &Ccb->DirectoryCB->NameInformation.FileName,
3809 try_return( ntStatus);
3812 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3813 AFS_TRACE_LEVEL_VERBOSE,
3814 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3815 &Ccb->DirectoryCB->NameInformation.FileName,
3816 ulFileInformationClass);
3827 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3830 IN OUT LONG *Length)
3833 NTSTATUS ntStatus = STATUS_SUCCESS;
3834 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3835 FILE_INFORMATION_CLASS ulFileInformationClass;
3840 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3842 switch( ulFileInformationClass)
3845 case FileBasicInformation:
3848 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3849 AFS_TRACE_LEVEL_VERBOSE,
3850 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3852 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3854 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3856 pBasic->CreationTime.QuadPart = 0;
3857 pBasic->LastAccessTime.QuadPart = 0;
3858 pBasic->ChangeTime.QuadPart = 0;
3859 pBasic->LastWriteTime.QuadPart = 0;
3860 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
3862 *Length -= sizeof( FILE_BASIC_INFORMATION);
3866 ntStatus = STATUS_BUFFER_TOO_SMALL;
3872 case FileStandardInformation:
3875 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3876 AFS_TRACE_LEVEL_VERBOSE,
3877 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
3879 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3881 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3883 pStandard->NumberOfLinks = 1;
3884 pStandard->DeletePending = 0;
3885 pStandard->AllocationSize.QuadPart = 0;
3886 pStandard->EndOfFile.QuadPart = 0;
3887 pStandard->Directory = 0;
3889 *Length -= sizeof( FILE_STANDARD_INFORMATION);
3893 ntStatus = STATUS_BUFFER_TOO_SMALL;
3899 case FileNormalizedNameInformation:
3900 case FileNameInformation:
3903 ULONG ulCopyLength = 0;
3904 AFSFcb *pFcb = NULL;
3905 AFSCcb *pCcb = NULL;
3906 USHORT usFullNameLength = 0;
3907 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3908 UNICODE_STRING uniName;
3910 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3911 AFS_TRACE_LEVEL_VERBOSE,
3912 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
3914 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3915 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3917 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
3919 ntStatus = STATUS_BUFFER_TOO_SMALL;
3923 RtlZeroMemory( pNameInfo,
3926 usFullNameLength = sizeof( WCHAR) +
3927 AFSServerName.Length +
3928 pCcb->FullFileName.Length;
3930 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
3932 ulCopyLength = (LONG)usFullNameLength;
3936 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3937 ntStatus = STATUS_BUFFER_OVERFLOW;
3940 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
3942 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3944 if( ulCopyLength > 0)
3947 pNameInfo->FileName[ 0] = L'\\';
3948 ulCopyLength -= sizeof( WCHAR);
3950 *Length -= sizeof( WCHAR);
3952 if( ulCopyLength >= AFSServerName.Length)
3955 RtlCopyMemory( &pNameInfo->FileName[ 1],
3956 AFSServerName.Buffer,
3957 AFSServerName.Length);
3959 ulCopyLength -= AFSServerName.Length;
3960 *Length -= AFSServerName.Length;
3962 if( ulCopyLength >= pCcb->FullFileName.Length)
3965 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3966 pCcb->FullFileName.Buffer,
3967 pCcb->FullFileName.Length);
3969 ulCopyLength -= pCcb->FullFileName.Length;
3970 *Length -= pCcb->FullFileName.Length;
3972 uniName.Length = (USHORT)pNameInfo->FileNameLength;
3973 uniName.MaximumLength = uniName.Length;
3974 uniName.Buffer = pNameInfo->FileName;
3979 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3980 pCcb->FullFileName.Buffer,
3983 *Length -= ulCopyLength;
3985 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
3986 uniName.MaximumLength = uniName.Length;
3987 uniName.Buffer = pNameInfo->FileName;
3990 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3991 AFS_TRACE_LEVEL_VERBOSE,
3992 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4000 case FileInternalInformation:
4003 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4005 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4006 AFS_TRACE_LEVEL_VERBOSE,
4007 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
4009 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4012 pInternalInfo->IndexNumber.HighPart = 0;
4014 pInternalInfo->IndexNumber.LowPart = 0;
4016 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4021 ntStatus = STATUS_BUFFER_TOO_SMALL;
4027 case FileAllInformation:
4029 ntStatus = STATUS_INVALID_PARAMETER;
4031 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4032 AFS_TRACE_LEVEL_WARNING,
4033 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
4038 case FileEaInformation:
4040 ntStatus = STATUS_INVALID_PARAMETER;
4042 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4043 AFS_TRACE_LEVEL_WARNING,
4044 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
4049 case FilePositionInformation:
4051 ntStatus = STATUS_INVALID_PARAMETER;
4053 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4054 AFS_TRACE_LEVEL_WARNING,
4055 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
4060 case FileAlternateNameInformation:
4062 ntStatus = STATUS_INVALID_PARAMETER;
4064 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4065 AFS_TRACE_LEVEL_WARNING,
4066 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
4071 case FileNetworkOpenInformation:
4073 ntStatus = STATUS_INVALID_PARAMETER;
4075 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4076 AFS_TRACE_LEVEL_WARNING,
4077 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
4082 case FileStreamInformation:
4084 ntStatus = STATUS_INVALID_PARAMETER;
4086 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4087 AFS_TRACE_LEVEL_WARNING,
4088 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
4093 case FileAttributeTagInformation:
4095 ntStatus = STATUS_INVALID_PARAMETER;
4097 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4098 AFS_TRACE_LEVEL_WARNING,
4099 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
4104 case FileRemoteProtocolInformation:
4106 ntStatus = STATUS_INVALID_PARAMETER;
4108 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4109 AFS_TRACE_LEVEL_WARNING,
4110 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
4115 case FileNetworkPhysicalNameInformation:
4117 ntStatus = STATUS_INVALID_PARAMETER;
4119 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4120 AFS_TRACE_LEVEL_WARNING,
4121 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
4128 ntStatus = STATUS_INVALID_PARAMETER;
4130 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4131 AFS_TRACE_LEVEL_WARNING,
4132 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4133 ulFileInformationClass);
4140 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4141 AFS_TRACE_LEVEL_VERBOSE,
4142 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",