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;
74 // Determine the type of request this request is
77 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
79 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
84 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
85 AFS_TRACE_LEVEL_ERROR,
86 "AFSQueryFileInfo Attempted access (%08lX) when pFcb == NULL\n",
89 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
92 lLength = (LONG)pIrpSp->Parameters.QueryFile.Length;
93 stFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
94 pBuffer = Irp->AssociatedIrp.SystemBuffer;
97 // Grab the main shared right off the bat
100 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
101 AFS_TRACE_LEVEL_VERBOSE,
102 "AFSQueryFileInfo Acquiring Fcb lock %08lX SHARED %08lX\n",
103 &pFcb->NPFcb->Resource,
104 PsGetCurrentThread());
106 AFSAcquireShared( &pFcb->NPFcb->Resource,
112 // Don't allow requests against IOCtl nodes
115 if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
118 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
119 AFS_TRACE_LEVEL_VERBOSE,
120 "AFSQueryFileInfo Processing request against SpecialShare Fcb\n");
122 ntStatus = AFSProcessShareQueryInfo( Irp,
126 try_return( ntStatus);
128 else if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
130 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
131 AFS_TRACE_LEVEL_VERBOSE,
132 "AFSQueryFileInfo request against PIOCtl Fcb\n");
134 ntStatus = AFSProcessPIOCtlQueryInfo( Irp,
139 try_return( ntStatus);
142 else if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
144 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
145 AFS_TRACE_LEVEL_VERBOSE,
146 "AFSQueryFileInfo request against Invalid Fcb\n");
148 try_return( ntStatus = STATUS_ACCESS_DENIED);
152 // Process the request
155 switch( stFileInformationClass)
158 case FileAllInformation:
161 PFILE_ALL_INFORMATION pAllInfo;
164 // For the all information class we'll typecast a local
165 // pointer to the output buffer and then call the
166 // individual routines to fill in the buffer.
169 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
171 ntStatus = AFSQueryBasicInfo( Irp,
173 &pAllInfo->BasicInformation,
176 if( !NT_SUCCESS( ntStatus))
179 try_return( ntStatus);
182 ntStatus = AFSQueryStandardInfo( Irp,
184 &pAllInfo->StandardInformation,
187 if( !NT_SUCCESS( ntStatus))
190 try_return( ntStatus);
193 ntStatus = AFSQueryInternalInfo( Irp,
195 &pAllInfo->InternalInformation,
198 if( !NT_SUCCESS( ntStatus))
201 try_return( ntStatus);
204 ntStatus = AFSQueryEaInfo( Irp,
206 &pAllInfo->EaInformation,
209 if( !NT_SUCCESS( ntStatus))
212 try_return( ntStatus);
215 ntStatus = AFSQueryAccess( Irp,
217 &pAllInfo->AccessInformation,
220 if( !NT_SUCCESS( ntStatus))
223 try_return( ntStatus);
226 ntStatus = AFSQueryPositionInfo( Irp,
228 &pAllInfo->PositionInformation,
231 if( !NT_SUCCESS( ntStatus))
234 try_return( ntStatus);
237 ntStatus = AFSQueryMode( Irp,
239 &pAllInfo->ModeInformation,
242 if( !NT_SUCCESS( ntStatus))
245 try_return( ntStatus);
248 ntStatus = AFSQueryAlignment( Irp,
250 &pAllInfo->AlignmentInformation,
253 if( !NT_SUCCESS( ntStatus))
256 try_return( ntStatus);
259 ntStatus = AFSQueryNameInfo( Irp,
261 &pAllInfo->NameInformation,
264 if( !NT_SUCCESS( ntStatus))
267 try_return( ntStatus);
273 case FileBasicInformation:
276 ntStatus = AFSQueryBasicInfo( Irp,
278 (PFILE_BASIC_INFORMATION)pBuffer,
284 case FileStandardInformation:
287 ntStatus = AFSQueryStandardInfo( Irp,
289 (PFILE_STANDARD_INFORMATION)pBuffer,
295 case FileInternalInformation:
298 ntStatus = AFSQueryInternalInfo( Irp,
300 (PFILE_INTERNAL_INFORMATION)pBuffer,
306 case FileEaInformation:
309 ntStatus = AFSQueryEaInfo( Irp,
311 (PFILE_EA_INFORMATION)pBuffer,
317 case FilePositionInformation:
320 ntStatus = AFSQueryPositionInfo( Irp,
322 (PFILE_POSITION_INFORMATION)pBuffer,
328 case FileNameInformation:
331 ntStatus = AFSQueryNameInfo( Irp,
333 (PFILE_NAME_INFORMATION)pBuffer,
339 case FileAlternateNameInformation:
342 ntStatus = AFSQueryShortNameInfo( Irp,
344 (PFILE_NAME_INFORMATION)pBuffer,
350 case FileNetworkOpenInformation:
353 ntStatus = AFSQueryNetworkInfo( Irp,
355 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
361 case FileStreamInformation:
364 ntStatus = AFSQueryStreamInfo( Irp,
366 (FILE_STREAM_INFORMATION *)pBuffer,
373 case FileAttributeTagInformation:
376 ntStatus = AFSQueryAttribTagInfo( Irp,
378 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
384 case FileRemoteProtocolInformation:
387 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
389 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
395 case FileNetworkPhysicalNameInformation:
398 ntStatus = AFSQueryPhysicalNameInfo( Irp,
400 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
408 ntStatus = STATUS_INVALID_PARAMETER;
415 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
420 AFSReleaseResource( &pFcb->NPFcb->Resource);
423 if( !NT_SUCCESS( ntStatus) &&
424 ntStatus != STATUS_INVALID_PARAMETER &&
425 ntStatus != STATUS_BUFFER_OVERFLOW)
429 pCcb->DirectoryCB != NULL)
432 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
433 AFS_TRACE_LEVEL_ERROR,
434 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
435 &pCcb->DirectoryCB->NameInformation.FileName,
436 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
437 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
438 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
439 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
444 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
449 "EXCEPTION - AFSQueryFileInfo\n");
451 AFSDumpTraceFilesFnc();
453 ntStatus = STATUS_UNSUCCESSFUL;
458 AFSReleaseResource( &pFcb->NPFcb->Resource);
462 AFSCompleteRequest( Irp,
469 // Function: AFSSetFileInfo
473 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
477 // A status is returned for the function
481 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
485 NTSTATUS ntStatus = STATUS_SUCCESS;
486 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
487 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
490 BOOLEAN bCompleteRequest = TRUE;
491 FILE_INFORMATION_CLASS FileInformationClass;
492 BOOLEAN bCanQueueRequest = FALSE;
493 PFILE_OBJECT pFileObject = NULL;
494 BOOLEAN bReleaseMain = FALSE;
495 BOOLEAN bUpdateFileInfo = FALSE;
496 AFSFileID stParentFileId;
501 pFileObject = pIrpSp->FileObject;
503 pFcb = (AFSFcb *)pFileObject->FsContext;
504 pCcb = (AFSCcb *)pFileObject->FsContext2;
509 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
510 AFS_TRACE_LEVEL_ERROR,
511 "AFSSetFileInfo Attempted access (%08lX) when pFcb == NULL\n",
514 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
517 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
518 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
524 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
525 AFS_TRACE_LEVEL_VERBOSE,
526 "AFSSetFileInfo Acquiring Fcb lock %08lX EXCL %08lX\n",
527 &pFcb->NPFcb->Resource,
528 PsGetCurrentThread());
530 AFSAcquireExcl( &pFcb->NPFcb->Resource,
536 // Don't allow requests against IOCtl nodes
539 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
542 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
543 AFS_TRACE_LEVEL_ERROR,
544 "AFSSetFileInfo Failing request against PIOCtl Fcb\n");
546 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
548 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
551 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
552 AFS_TRACE_LEVEL_VERBOSE,
553 "AFSSetFileInfo Processing request against SpecialShare Fcb\n");
555 ntStatus = AFSProcessShareSetInfo( Irp,
559 try_return( ntStatus);
562 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
565 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
566 AFS_TRACE_LEVEL_ERROR,
567 "AFSSetFileInfo Request failed due to read only volume\n",
570 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
573 if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB &&
574 FileInformationClass != FileDispositionInformation)
576 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
577 AFS_TRACE_LEVEL_VERBOSE,
578 "AFSSetFileInfo request against Invalid Fcb\n");
580 try_return( ntStatus = STATUS_ACCESS_DENIED);
584 // Ensure rename operations are synchronous
587 if( FileInformationClass == FileRenameInformation)
590 bCanQueueRequest = FALSE;
594 // Store away the parent fid
597 RtlZeroMemory( &stParentFileId,
600 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
602 stParentFileId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
606 // Process the request
609 switch( FileInformationClass)
612 case FileBasicInformation:
615 bUpdateFileInfo = TRUE;
617 ntStatus = AFSSetBasicInfo( Irp,
623 case FileDispositionInformation:
626 ntStatus = AFSSetDispositionInfo( Irp,
632 case FileRenameInformation:
635 ntStatus = AFSSetRenameInfo( Irp);
640 case FilePositionInformation:
643 ntStatus = AFSSetPositionInfo( Irp,
649 case FileLinkInformation:
652 ntStatus = STATUS_INVALID_DEVICE_REQUEST;
657 case FileAllocationInformation:
660 ntStatus = AFSSetAllocationInfo( Irp,
666 case FileEndOfFileInformation:
669 ntStatus = AFSSetEndOfFileInfo( Irp,
677 ntStatus = STATUS_INVALID_PARAMETER;
687 AFSReleaseResource( &pFcb->NPFcb->Resource);
690 if( NT_SUCCESS( ntStatus) &&
694 ntStatus = AFSUpdateFileInformation( &stParentFileId,
695 pFcb->ObjectInformation,
698 if( !NT_SUCCESS( ntStatus))
701 AFSAcquireExcl( &pFcb->NPFcb->Resource,
705 // Unwind the update and fail the request
708 AFSUnwindFileInfo( pFcb,
711 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
712 AFS_TRACE_LEVEL_ERROR,
713 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
714 &pCcb->DirectoryCB->NameInformation.FileName,
715 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
716 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
717 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
718 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
721 AFSReleaseResource( &pFcb->NPFcb->Resource);
725 if( !NT_SUCCESS( ntStatus))
729 pCcb->DirectoryCB != NULL)
732 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
733 AFS_TRACE_LEVEL_ERROR,
734 "AFSSetFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
735 &pCcb->DirectoryCB->NameInformation.FileName,
736 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
737 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
738 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
739 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
744 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
749 "EXCEPTION - AFSSetFileInfo\n");
751 AFSDumpTraceFilesFnc();
753 ntStatus = STATUS_UNSUCCESSFUL;
758 AFSReleaseResource( &pFcb->NPFcb->Resource);
762 AFSCompleteRequest( Irp,
769 // Function: AFSQueryBasicInfo
773 // This function is the handler for the query basic information request
777 // A status is returned for the function
781 AFSQueryBasicInfo( IN PIRP Irp,
782 IN AFSDirectoryCB *DirectoryCB,
783 IN OUT PFILE_BASIC_INFORMATION Buffer,
786 NTSTATUS ntStatus = STATUS_SUCCESS;
787 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
788 ULONG ulFileAttribs = 0;
791 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
792 AFSFileInfoCB stFileInfo;
793 AFSDirectoryCB *pParentDirectoryCB = NULL;
794 UNICODE_STRING uniParentPath;
796 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
799 RtlZeroMemory( Buffer,
802 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
804 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
805 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
807 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
810 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
812 AFSRetrieveParentPath( &pCcb->FullFileName,
815 RtlZeroMemory( &stFileInfo,
816 sizeof( AFSFileInfoCB));
819 // Can't hold the Fcb while evaluating the path, leads to lock inversion
822 AFSReleaseResource( &pFcb->NPFcb->Resource);
824 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
831 ulFileAttribs = stFileInfo.FileAttributes;
833 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
836 AFSAcquireShared( &pFcb->NPFcb->Resource,
841 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
842 AFS_TRACE_LEVEL_VERBOSE_2,
843 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
844 &pCcb->DirectoryCB->NameInformation.FileName,
845 pCcb->DirectoryCB->ObjectInformation->FileType,
846 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
849 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
850 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
851 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
852 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
853 Buffer->FileAttributes = ulFileAttribs;
855 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
856 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
859 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
861 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
865 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
869 *Length -= sizeof( FILE_BASIC_INFORMATION);
874 ntStatus = STATUS_BUFFER_TOO_SMALL;
881 AFSQueryStandardInfo( IN PIRP Irp,
882 IN AFSDirectoryCB *DirectoryCB,
883 IN OUT PFILE_STANDARD_INFORMATION Buffer,
887 NTSTATUS ntStatus = STATUS_SUCCESS;
890 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
891 AFSFileInfoCB stFileInfo;
892 AFSDirectoryCB *pParentDirectoryCB = NULL;
893 UNICODE_STRING uniParentPath;
894 ULONG ulFileAttribs = 0;
896 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
899 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
900 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
902 RtlZeroMemory( Buffer,
905 Buffer->NumberOfLinks = 1;
906 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
908 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
910 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
912 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
914 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
917 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
919 AFSRetrieveParentPath( &pCcb->FullFileName,
922 RtlZeroMemory( &stFileInfo,
923 sizeof( AFSFileInfoCB));
926 // Can't hold the Fcb while evaluating the path, leads to lock inversion
929 AFSReleaseResource( &pFcb->NPFcb->Resource);
931 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
938 ulFileAttribs = stFileInfo.FileAttributes;
941 AFSAcquireShared( &pFcb->NPFcb->Resource,
945 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
946 AFS_TRACE_LEVEL_VERBOSE_2,
947 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
948 &pCcb->DirectoryCB->NameInformation.FileName,
949 pCcb->DirectoryCB->ObjectInformation->FileType,
950 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
953 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
955 *Length -= sizeof( FILE_STANDARD_INFORMATION);
960 ntStatus = STATUS_BUFFER_TOO_SMALL;
967 AFSQueryInternalInfo( IN PIRP Irp,
969 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
973 NTSTATUS ntStatus = STATUS_SUCCESS;
975 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
978 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Volume;
980 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Vnode;
982 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
987 ntStatus = STATUS_BUFFER_TOO_SMALL;
994 AFSQueryEaInfo( IN PIRP Irp,
995 IN AFSDirectoryCB *DirectoryCB,
996 IN OUT PFILE_EA_INFORMATION Buffer,
1000 NTSTATUS ntStatus = STATUS_SUCCESS;
1002 RtlZeroMemory( Buffer,
1005 if( *Length >= sizeof( FILE_EA_INFORMATION))
1010 *Length -= sizeof( FILE_EA_INFORMATION);
1015 ntStatus = STATUS_BUFFER_TOO_SMALL;
1022 AFSQueryPositionInfo( IN PIRP Irp,
1024 IN OUT PFILE_POSITION_INFORMATION Buffer,
1025 IN OUT PLONG Length)
1028 NTSTATUS ntStatus = STATUS_SUCCESS;
1029 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1031 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1034 RtlZeroMemory( Buffer,
1037 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1039 *Length -= sizeof( FILE_POSITION_INFORMATION);
1044 ntStatus = STATUS_BUFFER_TOO_SMALL;
1051 AFSQueryAccess( IN PIRP Irp,
1053 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1054 IN OUT PLONG Length)
1057 NTSTATUS ntStatus = STATUS_SUCCESS;
1059 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1062 RtlZeroMemory( Buffer,
1065 Buffer->AccessFlags = 0;
1067 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1072 ntStatus = STATUS_BUFFER_TOO_SMALL;
1079 AFSQueryMode( IN PIRP Irp,
1081 IN OUT PFILE_MODE_INFORMATION Buffer,
1082 IN OUT PLONG Length)
1085 NTSTATUS ntStatus = STATUS_SUCCESS;
1087 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1090 RtlZeroMemory( Buffer,
1095 *Length -= sizeof( FILE_MODE_INFORMATION);
1100 ntStatus = STATUS_BUFFER_TOO_SMALL;
1107 AFSQueryAlignment( IN PIRP Irp,
1109 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1110 IN OUT PLONG Length)
1113 NTSTATUS ntStatus = STATUS_SUCCESS;
1115 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1118 RtlZeroMemory( Buffer,
1121 Buffer->AlignmentRequirement = 1;
1123 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1128 ntStatus = STATUS_BUFFER_TOO_SMALL;
1135 AFSQueryNameInfo( IN PIRP Irp,
1136 IN AFSDirectoryCB *DirectoryCB,
1137 IN OUT PFILE_NAME_INFORMATION Buffer,
1138 IN OUT PLONG Length)
1141 NTSTATUS ntStatus = STATUS_SUCCESS;
1142 ULONG ulCopyLength = 0;
1143 ULONG cchCopied = 0;
1144 AFSFcb *pFcb = NULL;
1145 AFSCcb *pCcb = NULL;
1146 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1147 BOOLEAN bAddLeadingSlash = FALSE;
1148 BOOLEAN bAddTrailingSlash = FALSE;
1149 USHORT usFullNameLength = 0;
1151 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1153 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1155 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1158 RtlZeroMemory( Buffer,
1161 if( pCcb->FullFileName.Length == 0 ||
1162 pCcb->FullFileName.Buffer[ 0] != L'\\')
1164 bAddLeadingSlash = TRUE;
1167 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1168 pCcb->FullFileName.Length > 0 &&
1169 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1171 bAddTrailingSlash = TRUE;
1174 usFullNameLength = sizeof( WCHAR) +
1175 AFSServerName.Length +
1176 pCcb->FullFileName.Length;
1178 if( bAddLeadingSlash)
1180 usFullNameLength += sizeof( WCHAR);
1183 if( bAddTrailingSlash)
1185 usFullNameLength += sizeof( WCHAR);
1188 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1191 ulCopyLength = (LONG)usFullNameLength;
1196 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1198 ntStatus = STATUS_BUFFER_OVERFLOW;
1201 Buffer->FileNameLength = (ULONG)usFullNameLength;
1203 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1205 if( ulCopyLength > 0)
1208 Buffer->FileName[ 0] = L'\\';
1209 ulCopyLength -= sizeof( WCHAR);
1211 *Length -= sizeof( WCHAR);
1214 if( ulCopyLength >= AFSServerName.Length)
1217 RtlCopyMemory( &Buffer->FileName[ 1],
1218 AFSServerName.Buffer,
1219 AFSServerName.Length);
1221 ulCopyLength -= AFSServerName.Length;
1222 *Length -= AFSServerName.Length;
1223 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1225 if ( ulCopyLength > 0 &&
1229 Buffer->FileName[ cchCopied] = L'\\';
1231 ulCopyLength -= sizeof( WCHAR);
1232 *Length -= sizeof( WCHAR);
1236 if( ulCopyLength >= pCcb->FullFileName.Length)
1239 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1240 pCcb->FullFileName.Buffer,
1241 pCcb->FullFileName.Length);
1243 ulCopyLength -= pCcb->FullFileName.Length;
1244 *Length -= pCcb->FullFileName.Length;
1245 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1247 if( ulCopyLength > 0 &&
1250 Buffer->FileName[ cchCopied] = L'\\';
1252 *Length -= sizeof( WCHAR);
1258 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1259 pCcb->FullFileName.Buffer,
1262 *Length -= ulCopyLength;
1270 ntStatus = STATUS_BUFFER_TOO_SMALL;
1277 AFSQueryShortNameInfo( IN PIRP Irp,
1278 IN AFSDirectoryCB *DirectoryCB,
1279 IN OUT PFILE_NAME_INFORMATION Buffer,
1280 IN OUT PLONG Length)
1283 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1284 ULONG ulCopyLength = 0;
1286 RtlZeroMemory( Buffer,
1289 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1293 // The short name IS the long name
1296 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1299 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1302 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1304 ntStatus = STATUS_SUCCESS;
1309 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1311 ntStatus = STATUS_BUFFER_OVERFLOW;
1314 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1316 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1318 if( ulCopyLength > 0)
1321 RtlCopyMemory( Buffer->FileName,
1322 DirectoryCB->NameInformation.FileName.Buffer,
1325 *Length -= ulCopyLength;
1332 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1335 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1338 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1340 ntStatus = STATUS_SUCCESS;
1345 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1347 ntStatus = STATUS_BUFFER_OVERFLOW;
1350 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1352 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1354 if( ulCopyLength > 0)
1357 RtlCopyMemory( Buffer->FileName,
1358 DirectoryCB->NameInformation.ShortName,
1359 Buffer->FileNameLength);
1361 *Length -= ulCopyLength;
1370 AFSQueryNetworkInfo( IN PIRP Irp,
1371 IN AFSDirectoryCB *DirectoryCB,
1372 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1373 IN OUT PLONG Length)
1376 NTSTATUS ntStatus = STATUS_SUCCESS;
1377 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1378 AFSFcb *pFcb = NULL;
1379 AFSCcb *pCcb = NULL;
1380 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1381 AFSFileInfoCB stFileInfo;
1382 AFSDirectoryCB *pParentDirectoryCB = NULL;
1383 UNICODE_STRING uniParentPath;
1384 ULONG ulFileAttribs = 0;
1386 RtlZeroMemory( Buffer,
1389 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1392 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1394 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1395 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1397 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1400 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1402 AFSRetrieveParentPath( &pCcb->FullFileName,
1405 RtlZeroMemory( &stFileInfo,
1406 sizeof( AFSFileInfoCB));
1409 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1412 AFSReleaseResource( &pFcb->NPFcb->Resource);
1414 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1421 ulFileAttribs = stFileInfo.FileAttributes;
1423 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1426 AFSAcquireShared( &pFcb->NPFcb->Resource,
1430 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1431 AFS_TRACE_LEVEL_VERBOSE_2,
1432 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1433 &pCcb->DirectoryCB->NameInformation.FileName,
1434 pCcb->DirectoryCB->ObjectInformation->FileType,
1435 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1438 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1439 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1440 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1441 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1443 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1444 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1446 Buffer->FileAttributes = ulFileAttribs;
1448 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1449 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1452 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1455 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1460 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1464 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1469 ntStatus = STATUS_BUFFER_TOO_SMALL;
1476 AFSQueryStreamInfo( IN PIRP Irp,
1477 IN AFSDirectoryCB *DirectoryCB,
1478 IN OUT FILE_STREAM_INFORMATION *Buffer,
1479 IN OUT PLONG Length)
1482 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1483 ULONG ulCopyLength = 0;
1484 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1486 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1489 RtlZeroMemory( Buffer,
1492 Buffer->NextEntryOffset = 0;
1495 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1498 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1503 ntStatus = STATUS_SUCCESS;
1508 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1510 ntStatus = STATUS_BUFFER_OVERFLOW;
1513 Buffer->StreamNameLength = 14; // ::$DATA
1515 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1517 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1519 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1521 if( ulCopyLength > 0)
1524 RtlCopyMemory( Buffer->StreamName,
1528 *Length -= ulCopyLength;
1534 Buffer->StreamNameLength = 0; // No stream for a directory
1536 // The response size is zero
1538 ntStatus = STATUS_SUCCESS;
1546 AFSQueryAttribTagInfo( IN PIRP Irp,
1547 IN AFSDirectoryCB *DirectoryCB,
1548 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1549 IN OUT PLONG Length)
1552 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1553 ULONG ulCopyLength = 0;
1554 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1555 AFSFcb *pFcb = NULL;
1556 AFSCcb *pCcb = NULL;
1557 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1558 AFSFileInfoCB stFileInfo;
1559 AFSDirectoryCB *pParentDirectoryCB = NULL;
1560 UNICODE_STRING uniParentPath;
1561 ULONG ulFileAttribs = 0;
1563 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1566 RtlZeroMemory( Buffer,
1569 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1571 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1572 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1574 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1577 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1579 AFSRetrieveParentPath( &pCcb->FullFileName,
1582 RtlZeroMemory( &stFileInfo,
1583 sizeof( AFSFileInfoCB));
1586 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1589 AFSReleaseResource( &pFcb->NPFcb->Resource);
1591 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1598 ulFileAttribs = stFileInfo.FileAttributes;
1600 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1603 AFSAcquireShared( &pFcb->NPFcb->Resource,
1607 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1608 AFS_TRACE_LEVEL_VERBOSE_2,
1609 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1610 &pCcb->DirectoryCB->NameInformation.FileName,
1611 pCcb->DirectoryCB->ObjectInformation->FileType,
1612 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1615 Buffer->FileAttributes = ulFileAttribs;
1617 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1618 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1621 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1624 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1629 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1633 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1635 Buffer->ReparseTag = IO_REPARSE_TAG_SURROGATE|IO_REPARSE_TAG_OPENAFS_DFS;
1638 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1640 ntStatus = STATUS_SUCCESS;
1647 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1648 IN AFSDirectoryCB *DirectoryCB,
1649 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1650 IN OUT PLONG Length)
1653 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1654 ULONG ulCopyLength = 0;
1655 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1657 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1660 RtlZeroMemory( Buffer,
1663 Buffer->StructureVersion = 1;
1665 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1667 Buffer->Protocol = WNNC_NET_OPENAFS;
1669 Buffer->ProtocolMajorVersion = 3;
1671 Buffer->ProtocolMinorVersion = 0;
1673 Buffer->ProtocolRevision = 0;
1675 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1677 ntStatus = STATUS_SUCCESS;
1684 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1685 IN AFSDirectoryCB *DirectoryCB,
1686 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1687 IN OUT PLONG Length)
1690 NTSTATUS ntStatus = STATUS_SUCCESS;
1691 ULONG ulCopyLength = 0;
1692 ULONG cchCopied = 0;
1693 AFSFcb *pFcb = NULL;
1694 AFSCcb *pCcb = NULL;
1695 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1696 BOOLEAN bAddLeadingSlash = FALSE;
1697 USHORT usFullNameLength = 0;
1699 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1701 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1703 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1706 RtlZeroMemory( Buffer,
1709 if( pCcb->FullFileName.Length == 0 ||
1710 pCcb->FullFileName.Buffer[ 0] != L'\\')
1712 bAddLeadingSlash = TRUE;
1715 usFullNameLength = pCcb->FullFileName.Length;
1717 if( bAddLeadingSlash)
1719 usFullNameLength += sizeof( WCHAR);
1722 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1724 ulCopyLength = (LONG)usFullNameLength;
1729 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1731 ntStatus = STATUS_BUFFER_OVERFLOW;
1734 Buffer->FileNameLength = (ULONG)usFullNameLength;
1736 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1738 if( ulCopyLength > 0)
1741 if( bAddLeadingSlash)
1744 Buffer->FileName[ cchCopied] = L'\\';
1746 ulCopyLength -= sizeof( WCHAR);
1747 *Length -= sizeof( WCHAR);
1751 if( ulCopyLength >= pCcb->FullFileName.Length)
1754 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1755 pCcb->FullFileName.Buffer,
1756 pCcb->FullFileName.Length);
1758 ulCopyLength -= pCcb->FullFileName.Length;
1759 *Length -= pCcb->FullFileName.Length;
1760 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1765 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1766 pCcb->FullFileName.Buffer,
1769 *Length -= ulCopyLength;
1776 ntStatus = STATUS_BUFFER_TOO_SMALL;
1783 AFSSetBasicInfo( IN PIRP Irp,
1784 IN AFSDirectoryCB *DirectoryCB)
1786 NTSTATUS ntStatus = STATUS_SUCCESS;
1787 PFILE_BASIC_INFORMATION pBuffer;
1788 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1789 ULONG ulNotifyFilter = 0;
1790 AFSCcb *pCcb = NULL;
1795 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1797 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1799 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1801 if( pBuffer->FileAttributes != (ULONGLONG)0)
1804 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1805 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1808 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1811 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1814 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1817 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1819 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1821 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1823 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1826 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1828 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1829 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1832 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1834 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1836 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1838 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1841 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1843 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1844 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1847 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1849 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1851 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1853 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1856 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1858 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1859 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1862 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1864 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1866 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1868 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1871 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1873 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1874 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1877 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1879 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
1881 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1883 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1886 if( ulNotifyFilter > 0)
1889 if( DirectoryCB->ObjectInformation->ParentObjectInformation != NULL)
1892 AFSFsRtlNotifyFullReportChange( DirectoryCB->ObjectInformation->ParentObjectInformation,
1894 (ULONG)ulNotifyFilter,
1895 (ULONG)FILE_ACTION_MODIFIED);
1908 AFSSetDispositionInfo( IN PIRP Irp,
1909 IN AFSDirectoryCB *DirectoryCB)
1911 NTSTATUS ntStatus = STATUS_SUCCESS;
1912 PFILE_DISPOSITION_INFORMATION pBuffer;
1913 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1914 AFSFcb *pFcb = NULL;
1915 AFSCcb *pCcb = NULL;
1920 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1922 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1924 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1927 // Can't delete the root
1930 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
1933 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1934 AFS_TRACE_LEVEL_ERROR,
1935 "AFSSetDispositionInfo Attempt to delete root entry\n");
1937 try_return( ntStatus = STATUS_CANNOT_DELETE);
1941 // If the file is read only then do not allow the delete
1944 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
1947 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1948 AFS_TRACE_LEVEL_ERROR,
1949 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
1950 &DirectoryCB->NameInformation.FileName);
1952 try_return( ntStatus = STATUS_CANNOT_DELETE);
1955 if( pBuffer->DeleteFile)
1959 // Check if the caller can delete the file
1962 ntStatus = AFSNotifyDelete( DirectoryCB,
1966 if( !NT_SUCCESS( ntStatus))
1969 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1970 AFS_TRACE_LEVEL_ERROR,
1971 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
1972 &DirectoryCB->NameInformation.FileName,
1975 try_return( ntStatus);
1978 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1982 // Check if this is a directory that there are not currently other opens
1985 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
1988 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1989 AFS_TRACE_LEVEL_ERROR,
1990 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
1991 &DirectoryCB->NameInformation.FileName,
1992 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount);
1994 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
1997 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2000 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2001 AFS_TRACE_LEVEL_ERROR,
2002 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2003 &DirectoryCB->NameInformation.FileName);
2005 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2008 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2009 AFS_TRACE_LEVEL_VERBOSE,
2010 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2012 &DirectoryCB->NameInformation.FileName);
2014 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2016 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2020 // Attempt to flush any outstanding data
2023 if( !MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2027 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2028 AFS_TRACE_LEVEL_ERROR,
2029 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2030 &DirectoryCB->NameInformation.FileName);
2032 try_return( ntStatus = STATUS_CANNOT_DELETE);
2036 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2037 // deadlock with Trend Micro's Enterprise anti-virus product
2038 // which attempts to open the file which is being deleted.
2041 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2042 AFS_TRACE_LEVEL_VERBOSE,
2043 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2045 &DirectoryCB->NameInformation.FileName);
2047 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2050 // Purge the cache as well
2053 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2056 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2062 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2070 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2074 // OK, should be good to go, set the flag in the file object
2077 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2088 AFSSetRenameInfo( IN PIRP Irp)
2091 NTSTATUS ntStatus = STATUS_SUCCESS;
2092 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2093 IO_STATUS_BLOCK stIoSb = {0,0};
2094 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2095 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2096 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2097 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2098 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2099 UNICODE_STRING uniTargetName, uniSourceName;
2100 BOOLEAN bReplaceIfExists = FALSE;
2101 UNICODE_STRING uniShortName;
2102 AFSDirectoryCB *pTargetDirEntry = NULL;
2103 ULONG ulTargetCRC = 0;
2104 BOOLEAN bTargetEntryExists = FALSE;
2105 AFSObjectInfoCB *pSrcObject = NULL, *pTargetObject = NULL;
2106 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2107 AFSFileID stNewFid, stTmpTargetFid;
2108 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2109 UNICODE_STRING uniFullTargetPath;
2110 BOOLEAN bCommonParent = FALSE;
2111 BOOLEAN bReleaseTargetDirLock = FALSE;
2112 BOOLEAN bReleaseSourceDirLock = FALSE;
2113 PERESOURCE pSourceDirLock = NULL;
2119 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2121 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2122 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2124 pSrcObject = pSrcFcb->ObjectInformation;
2125 pSrcParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2128 // Perform some basic checks to ensure FS integrity
2131 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2135 // Can't rename the root directory
2138 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2139 AFS_TRACE_LEVEL_ERROR,
2140 "AFSSetRenameInfo Attempt to rename root entry\n");
2142 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2145 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2149 // If there are any open children then fail the rename
2152 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2155 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2156 AFS_TRACE_LEVEL_ERROR,
2157 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2158 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2160 try_return( ntStatus = STATUS_ACCESS_DENIED);
2165 // Extract off the final component name from the Fcb
2168 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2169 uniSourceName.MaximumLength = uniSourceName.Length;
2171 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2174 // Resolve the target fileobject
2177 if( pTargetFileObj == NULL)
2181 // This is a simple rename. Here the target directory is the same as the source parent directory
2182 // and the name is retrieved from the system buffer information
2185 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2187 pTargetParentObject = pSrcParentObject;
2189 pTargetDcb = pTargetParentObject->Fcb;
2191 uniTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2192 uniTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2198 // So here we have the target directory taken from the targetfile object
2201 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2203 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2205 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2208 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2209 // it is only the target component of the rename operation
2212 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2216 // The quick check to see if they are not really performing a rename
2217 // Do the names match? Only do this where the parent directories are
2221 if( pTargetParentObject == pSrcParentObject)
2224 if( FsRtlAreNamesEqual( &uniTargetName,
2229 try_return( ntStatus = STATUS_SUCCESS);
2232 bCommonParent = TRUE;
2237 bCommonParent = FALSE;
2241 // We do not allow cross-volume renames to occur
2244 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2247 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2248 AFS_TRACE_LEVEL_ERROR,
2249 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2250 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2252 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2255 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2258 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2261 bReleaseTargetDirLock = TRUE;
2263 if( pTargetParentObject != pSrcParentObject)
2265 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2268 bReleaseSourceDirLock = TRUE;
2270 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2273 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2277 if( pTargetDirEntry == NULL)
2281 // Missed so perform a case insensitive lookup
2284 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2287 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2292 if( pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2297 // Try the short name
2299 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2305 // Increment our ref count on the dir entry
2308 if( pTargetDirEntry != NULL)
2311 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2313 lCount = InterlockedIncrement( &pTargetDirEntry->OpenReferenceCount);
2315 if( !bReplaceIfExists)
2318 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2319 AFS_TRACE_LEVEL_ERROR,
2320 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2321 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2322 &pTargetDirEntry->NameInformation.FileName);
2324 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2327 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2328 AFS_TRACE_LEVEL_ERROR,
2329 "AFSSetRenameInfo Target %wZ exists DE %p Count %08lX, performing delete of target\n",
2330 &pTargetDirEntry->NameInformation.FileName,
2332 pTargetDirEntry->OpenReferenceCount);
2335 // Pull the directory entry from the parent
2338 AFSRemoveDirNodeFromParent( pTargetParentObject,
2342 bTargetEntryExists = TRUE;
2346 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2347 AFS_TRACE_LEVEL_VERBOSE,
2348 "AFSSetRenameInfo Target does NOT exist, normal rename\n");
2352 // We need to remove the DirEntry from the parent node, update the index
2353 // and reinsert it into the parent tree. Note that for entries with the
2354 // same parent we do not pull the node from the enumeration list
2357 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2358 pSrcCcb->DirectoryCB,
2362 // OK, this is a simple rename. Issue the rename
2363 // request to the service.
2366 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2367 &pSrcCcb->AuthGroup,
2368 pSrcFcb->ObjectInformation->ParentObjectInformation,
2369 pTargetDcb->ObjectInformation,
2370 pSrcCcb->DirectoryCB,
2374 if( !NT_SUCCESS( ntStatus))
2378 // Attempt to re-insert the directory entry
2381 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2382 pSrcCcb->DirectoryCB,
2385 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2386 AFS_TRACE_LEVEL_ERROR,
2387 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2388 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2392 try_return( ntStatus);
2396 // Set the notification up for the source file
2399 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2400 !bTargetEntryExists)
2403 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2408 ulNotificationAction = FILE_ACTION_REMOVED;
2411 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2414 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2419 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2422 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2424 (ULONG)ulNotifyFilter,
2425 (ULONG)ulNotificationAction);
2428 // Update the name in the dir entry.
2431 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
2434 if( !NT_SUCCESS( ntStatus))
2438 // Attempt to re-insert the directory entry
2441 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2442 pSrcCcb->DirectoryCB,
2445 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2446 AFS_TRACE_LEVEL_ERROR,
2447 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
2448 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2452 try_return( ntStatus);
2456 // Update the object information block, if needed
2459 if( !AFSIsEqualFID( &pSrcObject->FileId,
2463 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
2467 // Remove the old information entry
2470 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2471 &pSrcObject->TreeEntry);
2473 RtlCopyMemory( &pSrcObject->FileId,
2475 sizeof( AFSFileID));
2478 // Insert the entry into the new object table.
2481 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
2483 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
2486 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
2491 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2492 &pSrcObject->TreeEntry)))
2496 // Lost a race, an ObjectInfo object already exists for this FID.
2497 // Let this copy be garbage collected.
2500 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
2504 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
2508 // Update the hash values for the name trees.
2511 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2514 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2517 if( pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
2518 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2523 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
2524 uniShortName.MaximumLength = uniShortName.Length;
2525 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
2527 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
2530 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2531 AFS_TRACE_LEVEL_VERBOSE,
2532 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
2534 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2539 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
2546 // Update the file index for the object in the new parent
2549 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
2553 // Re-insert the directory entry
2556 AFSInsertDirectoryNode( pTargetParentObject,
2557 pSrcCcb->DirectoryCB,
2561 // Update the parent pointer in the source object if they are different
2564 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
2567 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2569 lCount = InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2571 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
2573 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
2575 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
2577 ulNotificationAction = FILE_ACTION_ADDED;
2582 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
2586 // Now update the notification for the target file
2589 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
2591 (ULONG)ulNotifyFilter,
2592 (ULONG)ulNotificationAction);
2595 // If we performed the rename of the target because it existed, we now need to
2596 // delete the tmp target we created above
2599 if( bTargetEntryExists)
2602 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2603 AFS_TRACE_LEVEL_VERBOSE,
2604 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
2606 &pTargetDirEntry->NameInformation.FileName);
2608 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
2611 // Try and purge the cache map if this is a file
2614 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
2615 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
2616 pTargetDirEntry->OpenReferenceCount > 1)
2619 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
2621 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
2625 // Close the section in the event it was mapped
2628 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
2632 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2633 AFS_TRACE_LEVEL_ERROR,
2634 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
2635 &pTargetDirEntry->NameInformation.FileName);
2638 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
2641 ASSERT( pTargetDirEntry->OpenReferenceCount > 0);
2643 lCount = InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount); // The count we added above
2648 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2649 AFS_TRACE_LEVEL_VERBOSE,
2650 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
2652 &pTargetDirEntry->NameInformation.FileName);
2654 AFSDeleteDirEntry( pTargetParentObject,
2658 pTargetDirEntry = NULL;
2664 if( !NT_SUCCESS( ntStatus))
2667 if( bTargetEntryExists)
2669 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
2675 if( pTargetDirEntry != NULL)
2678 lCount = InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount);
2681 if( bReleaseTargetDirLock)
2683 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2686 if( bReleaseSourceDirLock)
2688 AFSReleaseResource( pSourceDirLock);
2696 AFSSetPositionInfo( IN PIRP Irp,
2697 IN AFSDirectoryCB *DirectoryCB)
2699 NTSTATUS ntStatus = STATUS_SUCCESS;
2700 PFILE_POSITION_INFORMATION pBuffer;
2701 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2703 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2705 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
2711 AFSSetAllocationInfo( IN PIRP Irp,
2712 IN AFSDirectoryCB *DirectoryCB)
2714 NTSTATUS ntStatus = STATUS_SUCCESS;
2715 PFILE_ALLOCATION_INFORMATION pBuffer;
2716 BOOLEAN bReleasePaging = FALSE;
2717 BOOLEAN bTellCc = FALSE;
2718 BOOLEAN bTellService = FALSE;
2719 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2720 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2721 AFSFcb *pFcb = NULL;
2722 AFSCcb *pCcb = NULL;
2723 LARGE_INTEGER liSaveAlloc;
2724 LARGE_INTEGER liSaveFileSize;
2725 LARGE_INTEGER liSaveVDL;
2727 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2729 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2731 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2734 // save values to put back
2736 liSaveAlloc = pFcb->Header.AllocationSize;
2737 liSaveFileSize = pFcb->Header.FileSize;
2738 liSaveVDL = pFcb->Header.ValidDataLength;
2740 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
2741 pIrpSp->Parameters.SetFile.AdvanceOnly)
2743 return STATUS_SUCCESS ;
2746 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2749 // Truncating the file
2751 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2752 &pBuffer->AllocationSize))
2755 ntStatus = STATUS_USER_MAPPED_FILE ;
2760 // If this is a truncation we need to grab the paging IO resource.
2763 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2764 AFS_TRACE_LEVEL_VERBOSE,
2765 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2766 &pFcb->NPFcb->PagingResource,
2767 PsGetCurrentThread());
2769 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2772 bReleasePaging = TRUE;
2775 // Must drop the Fcb Resource. When changing the file size
2776 // a deadlock can occur with Trend Micro's filter if the file
2777 // size is set to zero.
2780 AFSReleaseResource( &pFcb->NPFcb->Resource);
2782 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2784 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2787 // Tell Cc that Allocation is moved.
2791 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2794 // We are pulling the EOF back as well so we need to tell
2797 bTellService = TRUE;
2799 pFcb->Header.FileSize = pBuffer->AllocationSize;
2801 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
2809 // Tell Cc if allocation is increased.
2812 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2813 AFS_TRACE_LEVEL_VERBOSE,
2814 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2815 &pFcb->NPFcb->PagingResource,
2816 PsGetCurrentThread());
2818 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2821 bReleasePaging = TRUE;
2824 // Must drop the Fcb Resource. When changing the file size
2825 // a deadlock can occur with Trend Micro's filter if the file
2826 // size is set to zero.
2829 AFSReleaseResource( &pFcb->NPFcb->Resource);
2831 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
2833 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2835 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2839 // Now Tell the server if we have to
2843 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
2844 pFcb->ObjectInformation,
2848 if (NT_SUCCESS(ntStatus))
2851 // Trim extents if we told the service - the update has done an implicit
2852 // trim at the service.
2856 AFSTrimExtents( pFcb,
2857 &pFcb->Header.FileSize);
2860 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
2862 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2865 CcIsFileCached( pFileObject))
2867 CcSetFileSizes( pFileObject,
2868 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
2874 // Put the saved values back
2876 pFcb->Header.ValidDataLength = liSaveVDL;
2877 pFcb->Header.FileSize = liSaveFileSize;
2878 pFcb->Header.AllocationSize = liSaveAlloc;
2879 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
2880 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
2886 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
2888 AFSAcquireExcl( &pFcb->NPFcb->Resource,
2896 AFSSetEndOfFileInfo( IN PIRP Irp,
2897 IN AFSDirectoryCB *DirectoryCB)
2899 NTSTATUS ntStatus = STATUS_SUCCESS;
2900 PFILE_END_OF_FILE_INFORMATION pBuffer;
2901 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2902 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2903 LARGE_INTEGER liSaveSize;
2904 LARGE_INTEGER liSaveVDL;
2905 LARGE_INTEGER liSaveAlloc;
2906 BOOLEAN bModified = FALSE;
2907 BOOLEAN bReleasePaging = FALSE;
2908 BOOLEAN bTruncated = FALSE;
2909 AFSFcb *pFcb = NULL;
2910 AFSCcb *pCcb = NULL;
2912 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2914 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2916 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2918 liSaveSize = pFcb->Header.FileSize;
2919 liSaveAlloc = pFcb->Header.AllocationSize;
2920 liSaveVDL = pFcb->Header.ValidDataLength;
2922 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
2923 !pIrpSp->Parameters.SetFile.AdvanceOnly)
2926 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
2929 // Truncating the file
2930 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2931 &pBuffer->EndOfFile))
2934 ntStatus = STATUS_USER_MAPPED_FILE;
2940 // If this is a truncation we need to grab the paging
2943 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2944 AFS_TRACE_LEVEL_VERBOSE,
2945 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2946 &pFcb->NPFcb->PagingResource,
2947 PsGetCurrentThread());
2949 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2952 bReleasePaging = TRUE;
2955 // Must drop the Fcb Resource. When changing the file size
2956 // a deadlock can occur with Trend Micro's filter if the file
2957 // size is set to zero.
2960 AFSReleaseResource( &pFcb->NPFcb->Resource);
2962 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
2964 pFcb->Header.FileSize = pBuffer->EndOfFile;
2966 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
2968 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
2970 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
2973 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
2985 // extending the file, move EOF
2989 // If this is a truncation we need to grab the paging
2992 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2993 AFS_TRACE_LEVEL_VERBOSE,
2994 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2995 &pFcb->NPFcb->PagingResource,
2996 PsGetCurrentThread());
2998 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3001 bReleasePaging = TRUE;
3004 // Must drop the Fcb Resource. When changing the file size
3005 // a deadlock can occur with Trend Micro's filter if the file
3006 // size is set to zero.
3009 AFSReleaseResource( &pFcb->NPFcb->Resource);
3011 pFcb->Header.FileSize = pBuffer->EndOfFile;
3013 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3015 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3018 // And Allocation as needed.
3020 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3022 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3032 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3034 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3040 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
3041 pFcb->ObjectInformation,
3044 if( NT_SUCCESS(ntStatus))
3047 // We are now good to go so tell CC.
3049 CcSetFileSizes( pFileObject,
3050 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3053 // And give up those extents
3058 AFSTrimExtents( pFcb,
3059 &pFcb->Header.FileSize);
3064 pFcb->Header.ValidDataLength = liSaveVDL;
3065 pFcb->Header.FileSize = liSaveSize;
3066 pFcb->Header.AllocationSize = liSaveAlloc;
3067 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3068 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3075 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3077 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3085 AFSProcessShareSetInfo( IN IRP *Irp,
3090 NTSTATUS ntStatus = STATUS_SUCCESS;
3091 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3092 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3093 FILE_INFORMATION_CLASS ulFileInformationClass;
3094 void *pPipeInfo = NULL;
3098 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3100 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3101 AFS_TRACE_LEVEL_VERBOSE,
3102 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3103 &Ccb->DirectoryCB->NameInformation.FileName,
3104 ulFileInformationClass);
3106 pPipeInfo = AFSLockSystemBuffer( Irp,
3107 pIrpSp->Parameters.SetFile.Length);
3109 if( pPipeInfo == NULL)
3112 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3113 AFS_TRACE_LEVEL_ERROR,
3114 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3115 &Ccb->DirectoryCB->NameInformation.FileName);
3117 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3121 // Send the request to the service
3124 ntStatus = AFSNotifySetPipeInfo( Ccb,
3125 (ULONG)ulFileInformationClass,
3126 pIrpSp->Parameters.SetFile.Length,
3129 if( !NT_SUCCESS( ntStatus))
3132 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3133 AFS_TRACE_LEVEL_ERROR,
3134 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3135 &Ccb->DirectoryCB->NameInformation.FileName,
3138 try_return( ntStatus);
3141 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3142 AFS_TRACE_LEVEL_VERBOSE,
3143 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3144 &Ccb->DirectoryCB->NameInformation.FileName,
3145 ulFileInformationClass);
3156 AFSProcessShareQueryInfo( IN IRP *Irp,
3161 NTSTATUS ntStatus = STATUS_SUCCESS;
3162 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3163 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3164 FILE_INFORMATION_CLASS ulFileInformationClass;
3165 void *pPipeInfo = NULL;
3170 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3172 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3173 AFS_TRACE_LEVEL_VERBOSE,
3174 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3175 &Ccb->DirectoryCB->NameInformation.FileName,
3176 ulFileInformationClass);
3178 pPipeInfo = AFSLockSystemBuffer( Irp,
3179 pIrpSp->Parameters.QueryFile.Length);
3181 if( pPipeInfo == NULL)
3184 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3185 AFS_TRACE_LEVEL_ERROR,
3186 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3187 &Ccb->DirectoryCB->NameInformation.FileName);
3189 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3193 // Send the request to the service
3196 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3197 (ULONG)ulFileInformationClass,
3198 pIrpSp->Parameters.QueryFile.Length,
3200 (ULONG *)&Irp->IoStatus.Information);
3202 if( !NT_SUCCESS( ntStatus))
3205 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3206 AFS_TRACE_LEVEL_ERROR,
3207 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3208 &Ccb->DirectoryCB->NameInformation.FileName,
3211 try_return( ntStatus);
3214 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3215 AFS_TRACE_LEVEL_VERBOSE,
3216 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3217 &Ccb->DirectoryCB->NameInformation.FileName,
3218 ulFileInformationClass);
3229 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3232 IN OUT LONG *Length)
3235 NTSTATUS ntStatus = STATUS_SUCCESS;
3236 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3237 FILE_INFORMATION_CLASS ulFileInformationClass;
3242 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3244 switch( ulFileInformationClass)
3247 case FileBasicInformation:
3250 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3251 AFS_TRACE_LEVEL_VERBOSE,
3252 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3254 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3256 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3258 pBasic->CreationTime.QuadPart = 0;
3259 pBasic->LastAccessTime.QuadPart = 0;
3260 pBasic->ChangeTime.QuadPart = 0;
3261 pBasic->LastWriteTime.QuadPart = 0;
3262 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
3264 *Length -= sizeof( FILE_BASIC_INFORMATION);
3268 ntStatus = STATUS_BUFFER_TOO_SMALL;
3274 case FileStandardInformation:
3277 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3278 AFS_TRACE_LEVEL_VERBOSE,
3279 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
3281 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3283 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3285 pStandard->NumberOfLinks = 1;
3286 pStandard->DeletePending = 0;
3287 pStandard->AllocationSize.QuadPart = 0;
3288 pStandard->EndOfFile.QuadPart = 0;
3289 pStandard->Directory = 0;
3291 *Length -= sizeof( FILE_STANDARD_INFORMATION);
3295 ntStatus = STATUS_BUFFER_TOO_SMALL;
3301 case FileNameInformation:
3304 ULONG ulCopyLength = 0;
3305 AFSFcb *pFcb = NULL;
3306 AFSCcb *pCcb = NULL;
3307 USHORT usFullNameLength = 0;
3308 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3309 UNICODE_STRING uniName;
3311 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3312 AFS_TRACE_LEVEL_VERBOSE,
3313 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
3315 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3316 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3318 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
3320 ntStatus = STATUS_BUFFER_TOO_SMALL;
3324 RtlZeroMemory( pNameInfo,
3327 usFullNameLength = sizeof( WCHAR) +
3328 AFSServerName.Length +
3329 pCcb->FullFileName.Length;
3331 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
3333 ulCopyLength = (LONG)usFullNameLength;
3337 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3338 ntStatus = STATUS_BUFFER_OVERFLOW;
3341 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
3343 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3345 if( ulCopyLength > 0)
3348 pNameInfo->FileName[ 0] = L'\\';
3349 ulCopyLength -= sizeof( WCHAR);
3351 *Length -= sizeof( WCHAR);
3353 if( ulCopyLength >= AFSServerName.Length)
3356 RtlCopyMemory( &pNameInfo->FileName[ 1],
3357 AFSServerName.Buffer,
3358 AFSServerName.Length);
3360 ulCopyLength -= AFSServerName.Length;
3361 *Length -= AFSServerName.Length;
3363 if( ulCopyLength >= pCcb->FullFileName.Length)
3366 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3367 pCcb->FullFileName.Buffer,
3368 pCcb->FullFileName.Length);
3370 ulCopyLength -= pCcb->FullFileName.Length;
3371 *Length -= pCcb->FullFileName.Length;
3373 uniName.Length = (USHORT)pNameInfo->FileNameLength;
3374 uniName.MaximumLength = uniName.Length;
3375 uniName.Buffer = pNameInfo->FileName;
3380 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3381 pCcb->FullFileName.Buffer,
3384 *Length -= ulCopyLength;
3386 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
3387 uniName.MaximumLength = uniName.Length;
3388 uniName.Buffer = pNameInfo->FileName;
3391 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3392 AFS_TRACE_LEVEL_VERBOSE,
3393 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
3401 case FileInternalInformation:
3404 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3406 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3407 AFS_TRACE_LEVEL_VERBOSE,
3408 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
3410 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
3413 pInternalInfo->IndexNumber.HighPart = 0;
3415 pInternalInfo->IndexNumber.LowPart = 0;
3417 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
3422 ntStatus = STATUS_BUFFER_TOO_SMALL;
3428 case FileAllInformation:
3430 ntStatus = STATUS_INVALID_PARAMETER;
3432 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3433 AFS_TRACE_LEVEL_WARNING,
3434 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
3439 case FileEaInformation:
3441 ntStatus = STATUS_INVALID_PARAMETER;
3443 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3444 AFS_TRACE_LEVEL_WARNING,
3445 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
3450 case FilePositionInformation:
3452 ntStatus = STATUS_INVALID_PARAMETER;
3454 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3455 AFS_TRACE_LEVEL_WARNING,
3456 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
3461 case FileAlternateNameInformation:
3463 ntStatus = STATUS_INVALID_PARAMETER;
3465 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3466 AFS_TRACE_LEVEL_WARNING,
3467 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
3472 case FileNetworkOpenInformation:
3474 ntStatus = STATUS_INVALID_PARAMETER;
3476 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3477 AFS_TRACE_LEVEL_WARNING,
3478 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
3483 case FileStreamInformation:
3485 ntStatus = STATUS_INVALID_PARAMETER;
3487 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3488 AFS_TRACE_LEVEL_WARNING,
3489 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
3494 case FileAttributeTagInformation:
3496 ntStatus = STATUS_INVALID_PARAMETER;
3498 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3499 AFS_TRACE_LEVEL_WARNING,
3500 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
3505 case FileRemoteProtocolInformation:
3507 ntStatus = STATUS_INVALID_PARAMETER;
3509 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3510 AFS_TRACE_LEVEL_WARNING,
3511 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
3516 case FileNetworkPhysicalNameInformation:
3518 ntStatus = STATUS_INVALID_PARAMETER;
3520 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3521 AFS_TRACE_LEVEL_WARNING,
3522 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
3529 ntStatus = STATUS_INVALID_PARAMETER;
3531 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3532 AFS_TRACE_LEVEL_WARNING,
3533 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
3534 ulFileInformationClass);
3541 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3542 AFS_TRACE_LEVEL_VERBOSE,
3543 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",