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);
143 // Process the request
146 switch( stFileInformationClass)
149 case FileAllInformation:
152 PFILE_ALL_INFORMATION pAllInfo;
155 // For the all information class we'll typecast a local
156 // pointer to the output buffer and then call the
157 // individual routines to fill in the buffer.
160 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
162 ntStatus = AFSQueryBasicInfo( Irp,
164 &pAllInfo->BasicInformation,
167 if( !NT_SUCCESS( ntStatus))
170 try_return( ntStatus);
173 ntStatus = AFSQueryStandardInfo( Irp,
175 &pAllInfo->StandardInformation,
178 if( !NT_SUCCESS( ntStatus))
181 try_return( ntStatus);
184 ntStatus = AFSQueryInternalInfo( Irp,
186 &pAllInfo->InternalInformation,
189 if( !NT_SUCCESS( ntStatus))
192 try_return( ntStatus);
195 ntStatus = AFSQueryEaInfo( Irp,
197 &pAllInfo->EaInformation,
200 if( !NT_SUCCESS( ntStatus))
203 try_return( ntStatus);
206 ntStatus = AFSQueryAccess( Irp,
208 &pAllInfo->AccessInformation,
211 if( !NT_SUCCESS( ntStatus))
214 try_return( ntStatus);
217 ntStatus = AFSQueryPositionInfo( Irp,
219 &pAllInfo->PositionInformation,
222 if( !NT_SUCCESS( ntStatus))
225 try_return( ntStatus);
228 ntStatus = AFSQueryMode( Irp,
230 &pAllInfo->ModeInformation,
233 if( !NT_SUCCESS( ntStatus))
236 try_return( ntStatus);
239 ntStatus = AFSQueryAlignment( Irp,
241 &pAllInfo->AlignmentInformation,
244 if( !NT_SUCCESS( ntStatus))
247 try_return( ntStatus);
250 ntStatus = AFSQueryNameInfo( Irp,
252 &pAllInfo->NameInformation,
255 if( !NT_SUCCESS( ntStatus))
258 try_return( ntStatus);
264 case FileBasicInformation:
267 ntStatus = AFSQueryBasicInfo( Irp,
269 (PFILE_BASIC_INFORMATION)pBuffer,
275 case FileStandardInformation:
278 ntStatus = AFSQueryStandardInfo( Irp,
280 (PFILE_STANDARD_INFORMATION)pBuffer,
286 case FileInternalInformation:
289 ntStatus = AFSQueryInternalInfo( Irp,
291 (PFILE_INTERNAL_INFORMATION)pBuffer,
297 case FileEaInformation:
300 ntStatus = AFSQueryEaInfo( Irp,
302 (PFILE_EA_INFORMATION)pBuffer,
308 case FilePositionInformation:
311 ntStatus = AFSQueryPositionInfo( Irp,
313 (PFILE_POSITION_INFORMATION)pBuffer,
319 case FileNameInformation:
322 ntStatus = AFSQueryNameInfo( Irp,
324 (PFILE_NAME_INFORMATION)pBuffer,
330 case FileAlternateNameInformation:
333 ntStatus = AFSQueryShortNameInfo( Irp,
335 (PFILE_NAME_INFORMATION)pBuffer,
341 case FileNetworkOpenInformation:
344 ntStatus = AFSQueryNetworkInfo( Irp,
346 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
352 case FileStreamInformation:
355 ntStatus = AFSQueryStreamInfo( Irp,
357 (FILE_STREAM_INFORMATION *)pBuffer,
364 case FileAttributeTagInformation:
367 ntStatus = AFSQueryAttribTagInfo( Irp,
369 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
375 case FileRemoteProtocolInformation:
378 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
380 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
386 case FileNetworkPhysicalNameInformation:
389 ntStatus = AFSQueryPhysicalNameInfo( Irp,
391 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
399 ntStatus = STATUS_INVALID_PARAMETER;
406 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
411 AFSReleaseResource( &pFcb->NPFcb->Resource);
414 if( !NT_SUCCESS( ntStatus) &&
415 ntStatus != STATUS_INVALID_PARAMETER &&
416 ntStatus != STATUS_BUFFER_OVERFLOW)
420 pCcb->DirectoryCB != NULL)
423 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
424 AFS_TRACE_LEVEL_ERROR,
425 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
426 &pCcb->DirectoryCB->NameInformation.FileName,
427 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
428 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
429 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
430 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
435 __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
440 "EXCEPTION - AFSQueryFileInfo\n");
442 ntStatus = STATUS_UNSUCCESSFUL;
447 AFSReleaseResource( &pFcb->NPFcb->Resource);
451 AFSCompleteRequest( Irp,
458 // Function: AFSSetFileInfo
462 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
466 // A status is returned for the function
470 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
474 NTSTATUS ntStatus = STATUS_SUCCESS;
475 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
476 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
479 BOOLEAN bCompleteRequest = TRUE;
480 FILE_INFORMATION_CLASS FileInformationClass;
481 BOOLEAN bCanQueueRequest = FALSE;
482 PFILE_OBJECT pFileObject = NULL;
483 BOOLEAN bReleaseMain = FALSE;
484 BOOLEAN bUpdateFileInfo = FALSE;
485 AFSFileID stParentFileId;
490 pFileObject = pIrpSp->FileObject;
492 pFcb = (AFSFcb *)pFileObject->FsContext;
493 pCcb = (AFSCcb *)pFileObject->FsContext2;
498 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
499 AFS_TRACE_LEVEL_ERROR,
500 "AFSSetFileInfo Attempted access (%08lX) when pFcb == NULL\n",
503 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
506 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
507 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
513 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
514 AFS_TRACE_LEVEL_VERBOSE,
515 "AFSSetFileInfo Acquiring Fcb lock %08lX EXCL %08lX\n",
516 &pFcb->NPFcb->Resource,
517 PsGetCurrentThread());
519 AFSAcquireExcl( &pFcb->NPFcb->Resource,
525 // Don't allow requests against IOCtl nodes
528 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
531 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
532 AFS_TRACE_LEVEL_ERROR,
533 "AFSSetFileInfo Failing request against PIOCtl Fcb\n");
535 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
537 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
540 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
541 AFS_TRACE_LEVEL_VERBOSE,
542 "AFSSetFileInfo Processing request against SpecialShare Fcb\n");
544 ntStatus = AFSProcessShareSetInfo( Irp,
548 try_return( ntStatus);
551 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
554 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
555 AFS_TRACE_LEVEL_ERROR,
556 "AFSSetFileInfo Request failed due to read only volume\n",
559 try_return( ntStatus = STATUS_ACCESS_DENIED);
563 // Ensure rename operations are synchronous
566 if( FileInformationClass == FileRenameInformation)
569 bCanQueueRequest = FALSE;
573 // Store away the parent fid
576 RtlZeroMemory( &stParentFileId,
579 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
581 stParentFileId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
585 // Process the request
588 switch( FileInformationClass)
591 case FileBasicInformation:
594 bUpdateFileInfo = TRUE;
596 ntStatus = AFSSetBasicInfo( Irp,
602 case FileDispositionInformation:
605 ntStatus = AFSSetDispositionInfo( Irp,
611 case FileRenameInformation:
614 ntStatus = AFSSetRenameInfo( Irp);
619 case FilePositionInformation:
622 ntStatus = AFSSetPositionInfo( Irp,
628 case FileLinkInformation:
631 ntStatus = STATUS_INVALID_DEVICE_REQUEST;
636 case FileAllocationInformation:
639 ntStatus = AFSSetAllocationInfo( Irp,
645 case FileEndOfFileInformation:
648 ntStatus = AFSSetEndOfFileInfo( Irp,
656 ntStatus = STATUS_INVALID_PARAMETER;
666 AFSReleaseResource( &pFcb->NPFcb->Resource);
669 if( NT_SUCCESS( ntStatus) &&
673 ntStatus = AFSUpdateFileInformation( &stParentFileId,
674 pFcb->ObjectInformation,
677 if( !NT_SUCCESS( ntStatus))
680 AFSAcquireExcl( &pFcb->NPFcb->Resource,
684 // Unwind the update and fail the request
687 AFSUnwindFileInfo( pFcb,
690 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
691 AFS_TRACE_LEVEL_ERROR,
692 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
693 &pCcb->DirectoryCB->NameInformation.FileName,
694 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
695 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
696 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
697 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
700 AFSReleaseResource( &pFcb->NPFcb->Resource);
704 if( !NT_SUCCESS( ntStatus))
708 pCcb->DirectoryCB != NULL)
711 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
712 AFS_TRACE_LEVEL_ERROR,
713 "AFSSetFileInfo Failed to process 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,
723 __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
728 "EXCEPTION - AFSSetFileInfo\n");
730 ntStatus = STATUS_UNSUCCESSFUL;
733 AFSCompleteRequest( Irp,
740 // Function: AFSQueryBasicInfo
744 // This function is the handler for the query basic information request
748 // A status is returned for the function
752 AFSQueryBasicInfo( IN PIRP Irp,
753 IN AFSDirectoryCB *DirectoryCB,
754 IN OUT PFILE_BASIC_INFORMATION Buffer,
757 NTSTATUS ntStatus = STATUS_SUCCESS;
758 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
759 ULONG ulFileAttribs = 0;
762 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
763 AFSFileInfoCB stFileInfo;
764 AFSDirectoryCB *pParentDirectoryCB = NULL;
765 UNICODE_STRING uniParentPath;
767 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
770 RtlZeroMemory( Buffer,
773 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
775 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
776 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
778 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
781 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
783 AFSRetrieveParentPath( &pCcb->FullFileName,
786 RtlZeroMemory( &stFileInfo,
787 sizeof( AFSFileInfoCB));
790 // Can't hold the Fcb while evaluating the path, leads to lock inversion
793 AFSReleaseResource( &pFcb->NPFcb->Resource);
795 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
801 ulFileAttribs = stFileInfo.FileAttributes;
803 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
806 AFSAcquireShared( &pFcb->NPFcb->Resource,
811 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
812 AFS_TRACE_LEVEL_VERBOSE_2,
813 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
814 &pCcb->DirectoryCB->NameInformation.FileName,
815 pCcb->DirectoryCB->ObjectInformation->FileType,
816 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
819 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
820 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
821 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
822 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
823 Buffer->FileAttributes = ulFileAttribs;
825 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
826 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
829 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
831 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
835 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
839 *Length -= sizeof( FILE_BASIC_INFORMATION);
844 ntStatus = STATUS_BUFFER_TOO_SMALL;
851 AFSQueryStandardInfo( IN PIRP Irp,
852 IN AFSDirectoryCB *DirectoryCB,
853 IN OUT PFILE_STANDARD_INFORMATION Buffer,
857 NTSTATUS ntStatus = STATUS_SUCCESS;
860 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
861 AFSFileInfoCB stFileInfo;
862 AFSDirectoryCB *pParentDirectoryCB = NULL;
863 UNICODE_STRING uniParentPath;
864 ULONG ulFileAttribs = 0;
866 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
869 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
870 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
872 RtlZeroMemory( Buffer,
875 Buffer->NumberOfLinks = 1;
876 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
878 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
880 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
882 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
884 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
887 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
889 AFSRetrieveParentPath( &pCcb->FullFileName,
892 RtlZeroMemory( &stFileInfo,
893 sizeof( AFSFileInfoCB));
896 // Can't hold the Fcb while evaluating the path, leads to lock inversion
899 AFSReleaseResource( &pFcb->NPFcb->Resource);
901 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
907 ulFileAttribs = stFileInfo.FileAttributes;
910 AFSAcquireShared( &pFcb->NPFcb->Resource,
914 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
915 AFS_TRACE_LEVEL_VERBOSE_2,
916 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
917 &pCcb->DirectoryCB->NameInformation.FileName,
918 pCcb->DirectoryCB->ObjectInformation->FileType,
919 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
922 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
924 *Length -= sizeof( FILE_STANDARD_INFORMATION);
929 ntStatus = STATUS_BUFFER_TOO_SMALL;
936 AFSQueryInternalInfo( IN PIRP Irp,
938 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
942 NTSTATUS ntStatus = STATUS_SUCCESS;
944 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
947 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Volume;
949 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Vnode;
951 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
956 ntStatus = STATUS_BUFFER_TOO_SMALL;
963 AFSQueryEaInfo( IN PIRP Irp,
964 IN AFSDirectoryCB *DirectoryCB,
965 IN OUT PFILE_EA_INFORMATION Buffer,
969 NTSTATUS ntStatus = STATUS_SUCCESS;
971 RtlZeroMemory( Buffer,
974 if( *Length >= sizeof( FILE_EA_INFORMATION))
979 *Length -= sizeof( FILE_EA_INFORMATION);
984 ntStatus = STATUS_BUFFER_TOO_SMALL;
991 AFSQueryPositionInfo( IN PIRP Irp,
993 IN OUT PFILE_POSITION_INFORMATION Buffer,
997 NTSTATUS ntStatus = STATUS_SUCCESS;
998 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1000 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1003 RtlZeroMemory( Buffer,
1006 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1008 *Length -= sizeof( FILE_POSITION_INFORMATION);
1013 ntStatus = STATUS_BUFFER_TOO_SMALL;
1020 AFSQueryAccess( IN PIRP Irp,
1022 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1023 IN OUT PLONG Length)
1026 NTSTATUS ntStatus = STATUS_SUCCESS;
1028 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1031 RtlZeroMemory( Buffer,
1034 Buffer->AccessFlags = 0;
1036 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1041 ntStatus = STATUS_BUFFER_TOO_SMALL;
1048 AFSQueryMode( IN PIRP Irp,
1050 IN OUT PFILE_MODE_INFORMATION Buffer,
1051 IN OUT PLONG Length)
1054 NTSTATUS ntStatus = STATUS_SUCCESS;
1056 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1059 RtlZeroMemory( Buffer,
1064 *Length -= sizeof( FILE_MODE_INFORMATION);
1069 ntStatus = STATUS_BUFFER_TOO_SMALL;
1076 AFSQueryAlignment( IN PIRP Irp,
1078 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1079 IN OUT PLONG Length)
1082 NTSTATUS ntStatus = STATUS_SUCCESS;
1084 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1087 RtlZeroMemory( Buffer,
1090 Buffer->AlignmentRequirement = 1;
1092 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1097 ntStatus = STATUS_BUFFER_TOO_SMALL;
1104 AFSQueryNameInfo( IN PIRP Irp,
1105 IN AFSDirectoryCB *DirectoryCB,
1106 IN OUT PFILE_NAME_INFORMATION Buffer,
1107 IN OUT PLONG Length)
1110 NTSTATUS ntStatus = STATUS_SUCCESS;
1111 ULONG ulCopyLength = 0;
1112 ULONG cchCopied = 0;
1113 AFSFcb *pFcb = NULL;
1114 AFSCcb *pCcb = NULL;
1115 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1116 BOOLEAN bAddLeadingSlash = FALSE;
1117 BOOLEAN bAddTrailingSlash = FALSE;
1118 USHORT usFullNameLength = 0;
1120 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1122 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1124 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1127 RtlZeroMemory( Buffer,
1130 if( pCcb->FullFileName.Length == 0 ||
1131 pCcb->FullFileName.Buffer[ 0] != L'\\')
1133 bAddLeadingSlash = TRUE;
1136 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1137 pCcb->FullFileName.Length > 0 &&
1138 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1140 bAddTrailingSlash = TRUE;
1143 usFullNameLength = sizeof( WCHAR) +
1144 AFSServerName.Length +
1145 pCcb->FullFileName.Length;
1147 if( bAddLeadingSlash)
1149 usFullNameLength += sizeof( WCHAR);
1152 if( bAddTrailingSlash)
1154 usFullNameLength += sizeof( WCHAR);
1157 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1160 ulCopyLength = (LONG)usFullNameLength;
1165 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1167 ntStatus = STATUS_BUFFER_OVERFLOW;
1170 Buffer->FileNameLength = (ULONG)usFullNameLength;
1172 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1174 if( ulCopyLength > 0)
1177 Buffer->FileName[ 0] = L'\\';
1178 ulCopyLength -= sizeof( WCHAR);
1180 *Length -= sizeof( WCHAR);
1183 if( ulCopyLength >= AFSServerName.Length)
1186 RtlCopyMemory( &Buffer->FileName[ 1],
1187 AFSServerName.Buffer,
1188 AFSServerName.Length);
1190 ulCopyLength -= AFSServerName.Length;
1191 *Length -= AFSServerName.Length;
1192 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1194 if ( ulCopyLength > 0 &&
1198 Buffer->FileName[ cchCopied] = L'\\';
1200 ulCopyLength -= sizeof( WCHAR);
1201 *Length -= sizeof( WCHAR);
1205 if( ulCopyLength >= pCcb->FullFileName.Length)
1208 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1209 pCcb->FullFileName.Buffer,
1210 pCcb->FullFileName.Length);
1212 ulCopyLength -= pCcb->FullFileName.Length;
1213 *Length -= pCcb->FullFileName.Length;
1214 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1216 if( ulCopyLength > 0 &&
1219 Buffer->FileName[ cchCopied] = L'\\';
1221 *Length -= sizeof( WCHAR);
1227 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1228 pCcb->FullFileName.Buffer,
1231 *Length -= ulCopyLength;
1239 ntStatus = STATUS_BUFFER_TOO_SMALL;
1246 AFSQueryShortNameInfo( IN PIRP Irp,
1247 IN AFSDirectoryCB *DirectoryCB,
1248 IN OUT PFILE_NAME_INFORMATION Buffer,
1249 IN OUT PLONG Length)
1252 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1253 ULONG ulCopyLength = 0;
1255 RtlZeroMemory( Buffer,
1258 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1262 // The short name IS the long name
1265 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1268 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1271 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1273 ntStatus = STATUS_SUCCESS;
1278 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1280 ntStatus = STATUS_BUFFER_OVERFLOW;
1283 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1285 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1287 if( ulCopyLength > 0)
1290 RtlCopyMemory( Buffer->FileName,
1291 DirectoryCB->NameInformation.FileName.Buffer,
1294 *Length -= ulCopyLength;
1301 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1304 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1307 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1309 ntStatus = STATUS_SUCCESS;
1314 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1316 ntStatus = STATUS_BUFFER_OVERFLOW;
1319 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1321 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1323 if( ulCopyLength > 0)
1326 RtlCopyMemory( Buffer->FileName,
1327 DirectoryCB->NameInformation.ShortName,
1328 Buffer->FileNameLength);
1330 *Length -= ulCopyLength;
1339 AFSQueryNetworkInfo( IN PIRP Irp,
1340 IN AFSDirectoryCB *DirectoryCB,
1341 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1342 IN OUT PLONG Length)
1345 NTSTATUS ntStatus = STATUS_SUCCESS;
1346 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1347 AFSFcb *pFcb = NULL;
1348 AFSCcb *pCcb = NULL;
1349 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1350 AFSFileInfoCB stFileInfo;
1351 AFSDirectoryCB *pParentDirectoryCB = NULL;
1352 UNICODE_STRING uniParentPath;
1353 ULONG ulFileAttribs = 0;
1355 RtlZeroMemory( Buffer,
1358 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1361 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1363 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1364 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1366 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1369 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1371 AFSRetrieveParentPath( &pCcb->FullFileName,
1374 RtlZeroMemory( &stFileInfo,
1375 sizeof( AFSFileInfoCB));
1378 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1381 AFSReleaseResource( &pFcb->NPFcb->Resource);
1383 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1389 ulFileAttribs = stFileInfo.FileAttributes;
1391 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1394 AFSAcquireShared( &pFcb->NPFcb->Resource,
1398 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1399 AFS_TRACE_LEVEL_VERBOSE_2,
1400 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1401 &pCcb->DirectoryCB->NameInformation.FileName,
1402 pCcb->DirectoryCB->ObjectInformation->FileType,
1403 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1406 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1407 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1408 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1409 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1411 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1412 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1414 Buffer->FileAttributes = ulFileAttribs;
1416 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1417 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1420 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1423 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1428 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1432 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1437 ntStatus = STATUS_BUFFER_TOO_SMALL;
1444 AFSQueryStreamInfo( IN PIRP Irp,
1445 IN AFSDirectoryCB *DirectoryCB,
1446 IN OUT FILE_STREAM_INFORMATION *Buffer,
1447 IN OUT PLONG Length)
1450 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1451 ULONG ulCopyLength = 0;
1452 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1454 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1457 RtlZeroMemory( Buffer,
1460 Buffer->NextEntryOffset = 0;
1463 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1466 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1471 ntStatus = STATUS_SUCCESS;
1476 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1478 ntStatus = STATUS_BUFFER_OVERFLOW;
1481 Buffer->StreamNameLength = 14; // ::$DATA
1483 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1485 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1487 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1489 if( ulCopyLength > 0)
1492 RtlCopyMemory( Buffer->StreamName,
1496 *Length -= ulCopyLength;
1502 Buffer->StreamNameLength = 0; // No stream for a directory
1504 // The response size is zero
1506 ntStatus = STATUS_SUCCESS;
1514 AFSQueryAttribTagInfo( IN PIRP Irp,
1515 IN AFSDirectoryCB *DirectoryCB,
1516 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1517 IN OUT PLONG Length)
1520 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1521 ULONG ulCopyLength = 0;
1522 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1523 AFSFcb *pFcb = NULL;
1524 AFSCcb *pCcb = NULL;
1525 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1526 AFSFileInfoCB stFileInfo;
1527 AFSDirectoryCB *pParentDirectoryCB = NULL;
1528 UNICODE_STRING uniParentPath;
1529 ULONG ulFileAttribs = 0;
1531 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1534 RtlZeroMemory( Buffer,
1537 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1539 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1540 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1542 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1545 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1547 AFSRetrieveParentPath( &pCcb->FullFileName,
1550 RtlZeroMemory( &stFileInfo,
1551 sizeof( AFSFileInfoCB));
1554 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1557 AFSReleaseResource( &pFcb->NPFcb->Resource);
1559 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1565 ulFileAttribs = stFileInfo.FileAttributes;
1567 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1570 AFSAcquireShared( &pFcb->NPFcb->Resource,
1574 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1575 AFS_TRACE_LEVEL_VERBOSE_2,
1576 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1577 &pCcb->DirectoryCB->NameInformation.FileName,
1578 pCcb->DirectoryCB->ObjectInformation->FileType,
1579 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1582 Buffer->FileAttributes = ulFileAttribs;
1584 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1585 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1588 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1591 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1596 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1600 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1602 Buffer->ReparseTag = IO_REPARSE_TAG_OPENAFS_DFS;
1605 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1607 ntStatus = STATUS_SUCCESS;
1614 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1615 IN AFSDirectoryCB *DirectoryCB,
1616 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1617 IN OUT PLONG Length)
1620 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1621 ULONG ulCopyLength = 0;
1622 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1624 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1627 RtlZeroMemory( Buffer,
1630 Buffer->StructureVersion = 1;
1632 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1634 Buffer->Protocol = WNNC_NET_OPENAFS;
1636 Buffer->ProtocolMajorVersion = 3;
1638 Buffer->ProtocolMinorVersion = 0;
1640 Buffer->ProtocolRevision = 0;
1642 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1644 ntStatus = STATUS_SUCCESS;
1651 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1652 IN AFSDirectoryCB *DirectoryCB,
1653 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1654 IN OUT PLONG Length)
1657 NTSTATUS ntStatus = STATUS_SUCCESS;
1658 ULONG ulCopyLength = 0;
1659 ULONG cchCopied = 0;
1660 AFSFcb *pFcb = NULL;
1661 AFSCcb *pCcb = NULL;
1662 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1663 BOOLEAN bAddLeadingSlash = FALSE;
1664 USHORT usFullNameLength = 0;
1666 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1668 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1670 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1673 RtlZeroMemory( Buffer,
1676 if( pCcb->FullFileName.Length == 0 ||
1677 pCcb->FullFileName.Buffer[ 0] != L'\\')
1679 bAddLeadingSlash = TRUE;
1682 usFullNameLength = pCcb->FullFileName.Length;
1684 if( bAddLeadingSlash)
1686 usFullNameLength += sizeof( WCHAR);
1689 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1691 ulCopyLength = (LONG)usFullNameLength;
1696 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1698 ntStatus = STATUS_BUFFER_OVERFLOW;
1701 Buffer->FileNameLength = (ULONG)usFullNameLength;
1703 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1705 if( ulCopyLength > 0)
1708 if( bAddLeadingSlash)
1711 Buffer->FileName[ cchCopied] = L'\\';
1713 ulCopyLength -= sizeof( WCHAR);
1714 *Length -= sizeof( WCHAR);
1718 if( ulCopyLength >= pCcb->FullFileName.Length)
1721 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1722 pCcb->FullFileName.Buffer,
1723 pCcb->FullFileName.Length);
1725 ulCopyLength -= pCcb->FullFileName.Length;
1726 *Length -= pCcb->FullFileName.Length;
1727 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1732 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1733 pCcb->FullFileName.Buffer,
1736 *Length -= ulCopyLength;
1743 ntStatus = STATUS_BUFFER_TOO_SMALL;
1750 AFSSetBasicInfo( IN PIRP Irp,
1751 IN AFSDirectoryCB *DirectoryCB)
1753 NTSTATUS ntStatus = STATUS_SUCCESS;
1754 PFILE_BASIC_INFORMATION pBuffer;
1755 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1756 ULONG ulNotifyFilter = 0;
1757 AFSCcb *pCcb = NULL;
1762 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1764 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1766 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1768 if( pBuffer->FileAttributes != (ULONGLONG)0)
1771 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1772 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1775 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1778 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1781 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1784 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1786 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1788 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1790 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1793 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1795 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1796 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1799 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1801 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1803 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1805 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1808 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1810 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1811 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1814 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1816 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1818 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1820 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1823 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1825 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1826 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1829 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1831 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1833 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1835 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1838 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1840 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1841 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1844 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1846 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
1848 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1850 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1853 if( ulNotifyFilter > 0)
1856 if( DirectoryCB->ObjectInformation->ParentObjectInformation != NULL)
1859 AFSFsRtlNotifyFullReportChange( DirectoryCB->ObjectInformation->ParentObjectInformation,
1861 (ULONG)ulNotifyFilter,
1862 (ULONG)FILE_ACTION_MODIFIED);
1875 AFSSetDispositionInfo( IN PIRP Irp,
1876 IN AFSDirectoryCB *DirectoryCB)
1878 NTSTATUS ntStatus = STATUS_SUCCESS;
1879 PFILE_DISPOSITION_INFORMATION pBuffer;
1880 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1881 AFSFcb *pFcb = NULL;
1882 AFSCcb *pCcb = NULL;
1887 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1889 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1891 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1894 // Can't delete the root
1897 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
1900 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1901 AFS_TRACE_LEVEL_ERROR,
1902 "AFSSetDispositionInfo Attempt to delete root entry\n");
1904 try_return( ntStatus = STATUS_CANNOT_DELETE);
1908 // If the file is read only then do not allow the delete
1911 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
1914 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1915 AFS_TRACE_LEVEL_ERROR,
1916 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
1917 &DirectoryCB->NameInformation.FileName);
1919 try_return( ntStatus = STATUS_CANNOT_DELETE);
1922 if( pBuffer->DeleteFile)
1926 // Check if the caller can delete the file
1929 ntStatus = AFSNotifyDelete( DirectoryCB,
1932 if( !NT_SUCCESS( ntStatus))
1935 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1936 AFS_TRACE_LEVEL_ERROR,
1937 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
1938 &DirectoryCB->NameInformation.FileName,
1941 try_return( ntStatus);
1944 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1948 // Check if this is a directory that there are not currently other opens
1951 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
1954 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1955 AFS_TRACE_LEVEL_ERROR,
1956 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
1957 &DirectoryCB->NameInformation.FileName,
1958 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount);
1960 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
1963 if( !AFSIsDirectoryEmptyForDelete( pFcb))
1966 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1967 AFS_TRACE_LEVEL_ERROR,
1968 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
1969 &DirectoryCB->NameInformation.FileName);
1971 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
1978 // Attempt to flush any outstanding data
1981 if( !MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
1985 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1986 AFS_TRACE_LEVEL_ERROR,
1987 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
1988 &DirectoryCB->NameInformation.FileName);
1990 try_return( ntStatus = STATUS_CANNOT_DELETE);
1994 // Purge the cache as well
1997 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2000 CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2007 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2008 AFS_TRACE_LEVEL_VERBOSE,
2009 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2011 &DirectoryCB->NameInformation.FileName);
2013 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2018 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2022 // OK, should be good to go, set the flag in the file object
2025 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2036 AFSSetRenameInfo( IN PIRP Irp)
2039 NTSTATUS ntStatus = STATUS_SUCCESS;
2040 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2041 IO_STATUS_BLOCK stIoSb = {0,0};
2042 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2043 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2044 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2045 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2046 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2047 UNICODE_STRING uniTargetName, uniSourceName;
2048 BOOLEAN bReplaceIfExists = FALSE;
2049 UNICODE_STRING uniShortName;
2050 AFSDirectoryCB *pTargetDirEntry = NULL;
2051 ULONG ulTargetCRC = 0;
2052 BOOLEAN bTargetEntryExists = FALSE;
2053 AFSObjectInfoCB *pSrcObject = NULL, *pTargetObject = NULL;
2054 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2055 AFSFileID stNewFid, stTmpTargetFid;
2056 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2057 UNICODE_STRING uniFullTargetPath;
2058 BOOLEAN bCommonParent = FALSE;
2060 BOOLEAN bReleaseVolumeLock = FALSE;
2061 BOOLEAN bReleaseTargetDirLock = FALSE;
2062 BOOLEAN bReleaseSourceDirLock = FALSE;
2063 PERESOURCE pSourceDirLock = NULL;
2068 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2070 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2071 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2073 pSrcObject = pSrcFcb->ObjectInformation;
2076 // Perform some basic checks to ensure FS integrity
2079 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2083 // Can't rename the root directory
2086 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2087 AFS_TRACE_LEVEL_ERROR,
2088 "AFSSetRenameInfo Attempt to rename root entry\n");
2090 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2093 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2097 // If there are any open children then fail the rename
2100 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2103 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2104 AFS_TRACE_LEVEL_ERROR,
2105 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2106 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2108 try_return( ntStatus = STATUS_ACCESS_DENIED);
2114 if( pSrcFcb->OpenHandleCount > 1)
2117 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2118 AFS_TRACE_LEVEL_ERROR,
2119 "AFSSetRenameInfo Attempt to rename directory with open references %wZ\n",
2120 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2122 try_return( ntStatus = STATUS_ACCESS_DENIED);
2127 // Resolve the target fileobject
2130 if( pTargetFileObj == NULL)
2134 // This is a simple rename. Here the target directory is the same as the source parent directory
2135 // and the name is retrieved from the system buffer information
2138 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2140 pTargetParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2142 pTargetDcb = pTargetParentObject->Fcb;
2144 uniTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2145 uniTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2151 // So here we have the target directory taken from the targetfile object
2154 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2156 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2158 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2161 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2162 // it is only the target component of the rename operation
2165 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2169 // We do not allow cross-volume renames to occur
2172 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2175 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2176 AFS_TRACE_LEVEL_ERROR,
2177 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2178 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2180 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2183 AFSAcquireExcl( pTargetParentObject->VolumeCB->VolumeLock,
2186 bReleaseVolumeLock = TRUE;
2188 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2191 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2194 bReleaseTargetDirLock = TRUE;
2196 if( pTargetParentObject != pSrcFcb->ObjectInformation->ParentObjectInformation)
2198 AFSAcquireExcl( pSrcFcb->ObjectInformation->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
2201 bReleaseSourceDirLock = TRUE;
2203 pSourceDirLock = pSrcFcb->ObjectInformation->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock;
2206 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2210 if( pTargetDirEntry == NULL)
2214 // Missed so perform a case insensitive lookup
2217 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2220 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2225 if( pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2230 // Try the short name
2232 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2238 // Increment our ref count on the dir entry
2241 if( pTargetDirEntry != NULL)
2244 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2246 InterlockedIncrement( &pTargetDirEntry->OpenReferenceCount);
2248 if( !bReplaceIfExists)
2251 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2252 AFS_TRACE_LEVEL_ERROR,
2253 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2254 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2255 &pTargetDirEntry->NameInformation.FileName);
2257 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2260 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2261 AFS_TRACE_LEVEL_ERROR,
2262 "AFSSetRenameInfo Target %wZ exists DE %p Count %08lX, performing delete of target\n",
2263 &pTargetDirEntry->NameInformation.FileName,
2265 pTargetDirEntry->OpenReferenceCount);
2268 // Pull the directory entry from the parent
2271 AFSRemoveDirNodeFromParent( pTargetParentObject,
2275 bTargetEntryExists = TRUE;
2279 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2280 AFS_TRACE_LEVEL_ERROR,
2281 "AFSSetRenameInfo Target Target does NOT exist, normal rename\n");
2285 // Extract off the final component name from the Fcb
2288 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2289 uniSourceName.MaximumLength = uniSourceName.Length;
2291 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2294 // The quick check to see if they are not really performing a rename
2295 // Do the names match? Only do this where the parent directories are
2299 if( pTargetParentObject == pSrcFcb->ObjectInformation->ParentObjectInformation)
2302 bCommonParent = TRUE;
2304 if( FsRtlAreNamesEqual( &uniTargetName,
2309 try_return( ntStatus = STATUS_SUCCESS);
2315 bCommonParent = FALSE;
2319 // We need to remove the DirEntry from the parent node, update the index
2320 // and reinsert it into the parent tree. Note that for entries with the
2321 // same parent we do not pull the node from the enumeration list
2324 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2325 pSrcCcb->DirectoryCB,
2328 oldFileIndex = pSrcCcb->DirectoryCB->FileIndex;
2334 // We always need to update the FileIndex since this entry will be put at the 'end'
2335 // of the enumeraiton list. If we don't it will cause recursion ... We do this
2336 // here to cover any failures which might occur below
2339 pSrcCcb->DirectoryCB->FileIndex =
2340 (ULONG)InterlockedIncrement( &pTargetDcb->ObjectInformation->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.ContentIndex);
2344 // OK, this is a simple rename. Issue the rename
2345 // request to the service.
2348 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2349 pSrcFcb->ObjectInformation->ParentObjectInformation,
2350 pTargetDcb->ObjectInformation,
2351 pSrcCcb->DirectoryCB,
2355 if( !NT_SUCCESS( ntStatus))
2359 // Attempt to re-insert the directory entry
2362 pSrcCcb->DirectoryCB->FileIndex = oldFileIndex;
2363 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2364 pSrcCcb->DirectoryCB,
2367 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2368 AFS_TRACE_LEVEL_ERROR,
2369 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2370 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2374 try_return( ntStatus);
2378 // Set the notification up for the source file
2381 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2382 !bTargetEntryExists)
2385 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2390 ulNotificationAction = FILE_ACTION_REMOVED;
2393 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2396 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2401 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2404 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2406 (ULONG)ulNotifyFilter,
2407 (ULONG)ulNotificationAction);
2410 // Update the name in the dir entry.
2413 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
2416 if( !NT_SUCCESS( ntStatus))
2420 // Attempt to re-insert the directory entry
2423 pSrcCcb->DirectoryCB->FileIndex = oldFileIndex;
2424 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2425 pSrcCcb->DirectoryCB,
2428 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2429 AFS_TRACE_LEVEL_ERROR,
2430 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
2431 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2435 try_return( ntStatus);
2439 // Update the object information block, if needed
2442 if( !AFSIsEqualFID( &pSrcObject->FileId,
2447 // Remove the old information entry
2450 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2451 &pSrcObject->TreeEntry);
2453 RtlCopyMemory( &pSrcObject->FileId,
2455 sizeof( AFSFileID));
2458 // Insert the entry into the new object table.
2461 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
2463 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
2466 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
2471 AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2472 &pSrcObject->TreeEntry);
2477 // Update the hash values for the name trees.
2480 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2483 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2486 if( pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
2487 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2492 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
2493 uniShortName.MaximumLength = uniShortName.Length;
2494 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
2496 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
2499 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2500 AFS_TRACE_LEVEL_VERBOSE,
2501 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
2503 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2508 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
2515 // Update the file index for the object in the new parent
2518 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
2522 // Re-insert the directory entry
2525 AFSInsertDirectoryNode( pTargetParentObject,
2526 pSrcCcb->DirectoryCB,
2530 // Update the parent pointer in the source object if they are different
2533 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
2536 InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2538 InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2540 InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
2542 InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
2544 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
2546 ulNotificationAction = FILE_ACTION_ADDED;
2551 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
2555 // Now update the notification for the target file
2558 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
2560 (ULONG)ulNotifyFilter,
2561 (ULONG)ulNotificationAction);
2564 // If we performed the rename of the target because it existed, we now need to
2565 // delete the tmp target we created above
2568 if( bTargetEntryExists)
2571 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2572 AFS_TRACE_LEVEL_VERBOSE,
2573 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
2575 &pTargetDirEntry->NameInformation.FileName);
2577 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
2580 // Try and purge the cache map if this is a file
2583 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
2584 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
2585 pTargetDirEntry->OpenReferenceCount > 1)
2588 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
2590 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
2594 // Close the section in the event it was mapped
2597 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
2601 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2602 AFS_TRACE_LEVEL_ERROR,
2603 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
2604 &pTargetDirEntry->NameInformation.FileName);
2607 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
2610 ASSERT( pTargetDirEntry->OpenReferenceCount > 0);
2612 InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount); // The count we added above
2614 if( pTargetDirEntry->OpenReferenceCount == 0)
2617 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2618 AFS_TRACE_LEVEL_VERBOSE,
2619 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
2621 &pTargetDirEntry->NameInformation.FileName);
2623 AFSDeleteDirEntry( pTargetParentObject,
2627 pTargetDirEntry = NULL;
2633 if( !NT_SUCCESS( ntStatus))
2636 if( bTargetEntryExists)
2638 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
2644 if( pTargetDirEntry != NULL)
2647 InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount);
2650 if( bReleaseVolumeLock)
2652 AFSReleaseResource( pTargetParentObject->VolumeCB->VolumeLock);
2655 if( bReleaseTargetDirLock)
2657 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2660 if( bReleaseSourceDirLock)
2662 AFSReleaseResource( pSourceDirLock);
2670 AFSSetPositionInfo( IN PIRP Irp,
2671 IN AFSDirectoryCB *DirectoryCB)
2673 NTSTATUS ntStatus = STATUS_SUCCESS;
2674 PFILE_POSITION_INFORMATION pBuffer;
2675 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2677 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2679 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
2685 AFSSetAllocationInfo( IN PIRP Irp,
2686 IN AFSDirectoryCB *DirectoryCB)
2688 NTSTATUS ntStatus = STATUS_SUCCESS;
2689 PFILE_ALLOCATION_INFORMATION pBuffer;
2690 BOOLEAN bReleasePaging = FALSE;
2691 BOOLEAN bTellCc = FALSE;
2692 BOOLEAN bTellService = FALSE;
2693 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2694 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2695 AFSFcb *pFcb = NULL;
2696 AFSCcb *pCcb = NULL;
2697 LARGE_INTEGER liSaveAlloc;
2698 LARGE_INTEGER liSaveFileSize;
2699 LARGE_INTEGER liSaveVDL;
2701 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2703 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2705 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2708 // save values to put back
2710 liSaveAlloc = pFcb->Header.AllocationSize;
2711 liSaveFileSize = pFcb->Header.FileSize;
2712 liSaveVDL = pFcb->Header.ValidDataLength;
2714 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
2715 pIrpSp->Parameters.SetFile.AdvanceOnly)
2717 return STATUS_SUCCESS ;
2720 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2723 // Truncating the file
2725 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2726 &pBuffer->AllocationSize))
2729 ntStatus = STATUS_USER_MAPPED_FILE ;
2734 // If this is a truncation we need to grab the paging IO resource.
2736 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2737 AFS_TRACE_LEVEL_VERBOSE,
2738 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2739 &pFcb->NPFcb->PagingResource,
2740 PsGetCurrentThread());
2742 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2745 bReleasePaging = TRUE;
2748 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2750 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2753 // Tell Cc that Allocation is moved.
2757 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2760 // We are pulling the EOF back as well so we need to tell
2763 bTellService = TRUE;
2765 pFcb->Header.FileSize = pBuffer->AllocationSize;
2767 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
2775 // Tell Cc if allocation is increased.
2777 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
2779 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2781 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2785 // Now Tell the server if we have to
2789 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
2790 pFcb->ObjectInformation,
2794 if (NT_SUCCESS(ntStatus))
2797 // Trim extents if we told the service - the update has done an implicit
2798 // trim at the service.
2802 AFSTrimExtents( pFcb,
2803 &pFcb->Header.FileSize);
2806 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
2808 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2811 CcIsFileCached( pFileObject))
2813 CcSetFileSizes( pFileObject,
2814 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
2820 // Put the saved values back
2822 pFcb->Header.ValidDataLength = liSaveVDL;
2823 pFcb->Header.FileSize = liSaveFileSize;
2824 pFcb->Header.AllocationSize = liSaveAlloc;
2825 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
2826 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
2832 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
2839 AFSSetEndOfFileInfo( IN PIRP Irp,
2840 IN AFSDirectoryCB *DirectoryCB)
2842 NTSTATUS ntStatus = STATUS_SUCCESS;
2843 PFILE_END_OF_FILE_INFORMATION pBuffer;
2844 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2845 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2846 LARGE_INTEGER liSaveSize;
2847 LARGE_INTEGER liSaveVDL;
2848 LARGE_INTEGER liSaveAlloc;
2849 BOOLEAN bModified = FALSE;
2850 BOOLEAN bReleasePaging = FALSE;
2851 BOOLEAN bTruncated = FALSE;
2852 AFSFcb *pFcb = NULL;
2853 AFSCcb *pCcb = NULL;
2855 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2857 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2859 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2861 liSaveSize = pFcb->Header.FileSize;
2862 liSaveAlloc = pFcb->Header.AllocationSize;
2863 liSaveVDL = pFcb->Header.ValidDataLength;
2865 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
2866 !pIrpSp->Parameters.SetFile.AdvanceOnly)
2869 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
2872 // Truncating the file
2873 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2874 &pBuffer->EndOfFile))
2877 ntStatus = STATUS_USER_MAPPED_FILE;
2882 // If this is a truncation we need to grab the paging
2885 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2886 AFS_TRACE_LEVEL_VERBOSE,
2887 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2888 &pFcb->NPFcb->PagingResource,
2889 PsGetCurrentThread());
2891 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2894 bReleasePaging = TRUE;
2896 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
2898 pFcb->Header.FileSize = pBuffer->EndOfFile;
2900 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
2902 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
2904 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
2907 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
2918 // extending the file, move EOF
2921 pFcb->Header.FileSize = pBuffer->EndOfFile;
2923 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
2925 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
2928 // And Allocation as needed.
2930 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
2932 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
2942 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
2944 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2950 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
2951 pFcb->ObjectInformation,
2954 if( NT_SUCCESS(ntStatus))
2957 // We are now good to go so tell CC.
2959 CcSetFileSizes( pFileObject,
2960 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
2963 // And give up those extents
2968 AFSTrimExtents( pFcb,
2969 &pFcb->Header.FileSize);
2974 pFcb->Header.ValidDataLength = liSaveVDL;
2975 pFcb->Header.FileSize = liSaveSize;
2976 pFcb->Header.AllocationSize = liSaveAlloc;
2977 pFcb->ObjectInformation->EndOfFile = liSaveSize;
2978 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
2985 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
2992 AFSProcessShareSetInfo( IN IRP *Irp,
2997 NTSTATUS ntStatus = STATUS_SUCCESS;
2998 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2999 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3000 FILE_INFORMATION_CLASS ulFileInformationClass;
3001 void *pPipeInfo = NULL;
3005 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3007 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3008 AFS_TRACE_LEVEL_VERBOSE,
3009 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3010 &Ccb->DirectoryCB->NameInformation.FileName,
3011 ulFileInformationClass);
3013 pPipeInfo = AFSLockSystemBuffer( Irp,
3014 pIrpSp->Parameters.SetFile.Length);
3016 if( pPipeInfo == NULL)
3019 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3020 AFS_TRACE_LEVEL_ERROR,
3021 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3022 &Ccb->DirectoryCB->NameInformation.FileName);
3024 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3028 // Send the request to the service
3031 ntStatus = AFSNotifySetPipeInfo( Ccb,
3032 (ULONG)ulFileInformationClass,
3033 pIrpSp->Parameters.SetFile.Length,
3036 if( !NT_SUCCESS( ntStatus))
3039 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3040 AFS_TRACE_LEVEL_ERROR,
3041 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3042 &Ccb->DirectoryCB->NameInformation.FileName,
3045 try_return( ntStatus);
3048 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3049 AFS_TRACE_LEVEL_VERBOSE,
3050 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3051 &Ccb->DirectoryCB->NameInformation.FileName,
3052 ulFileInformationClass);
3063 AFSProcessShareQueryInfo( IN IRP *Irp,
3068 NTSTATUS ntStatus = STATUS_SUCCESS;
3069 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3070 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3071 FILE_INFORMATION_CLASS ulFileInformationClass;
3072 void *pPipeInfo = NULL;
3077 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3079 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3080 AFS_TRACE_LEVEL_VERBOSE,
3081 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3082 &Ccb->DirectoryCB->NameInformation.FileName,
3083 ulFileInformationClass);
3085 pPipeInfo = AFSLockSystemBuffer( Irp,
3086 pIrpSp->Parameters.QueryFile.Length);
3088 if( pPipeInfo == NULL)
3091 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3092 AFS_TRACE_LEVEL_ERROR,
3093 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3094 &Ccb->DirectoryCB->NameInformation.FileName);
3096 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3100 // Send the request to the service
3103 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3104 (ULONG)ulFileInformationClass,
3105 pIrpSp->Parameters.QueryFile.Length,
3107 (ULONG *)&Irp->IoStatus.Information);
3109 if( !NT_SUCCESS( ntStatus))
3112 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3113 AFS_TRACE_LEVEL_ERROR,
3114 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3115 &Ccb->DirectoryCB->NameInformation.FileName,
3118 try_return( ntStatus);
3121 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3122 AFS_TRACE_LEVEL_VERBOSE,
3123 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3124 &Ccb->DirectoryCB->NameInformation.FileName,
3125 ulFileInformationClass);
3136 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3139 IN OUT LONG *Length)
3142 NTSTATUS ntStatus = STATUS_SUCCESS;
3143 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3144 FILE_INFORMATION_CLASS ulFileInformationClass;
3149 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3151 switch( ulFileInformationClass)
3154 case FileBasicInformation:
3157 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3159 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3161 pBasic->CreationTime.QuadPart = 0;
3162 pBasic->LastAccessTime.QuadPart = 0;
3163 pBasic->ChangeTime.QuadPart = 0;
3164 pBasic->LastWriteTime.QuadPart = 0;
3165 pBasic->FileAttributes = FILE_ATTRIBUTE_SYSTEM;
3167 *Length -= sizeof( FILE_BASIC_INFORMATION);
3171 ntStatus = STATUS_BUFFER_OVERFLOW;
3177 case FileStandardInformation:
3180 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3182 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3184 pStandard->NumberOfLinks = 1;
3185 pStandard->DeletePending = 0;
3186 pStandard->AllocationSize.QuadPart = 4096;
3187 pStandard->EndOfFile.QuadPart = 4096;
3188 pStandard->Directory = 0;
3190 *Length -= sizeof( FILE_STANDARD_INFORMATION);
3194 ntStatus = STATUS_BUFFER_OVERFLOW;
3200 case FileNameInformation:
3203 ULONG ulCopyLength = 0;
3204 AFSFcb *pFcb = NULL;
3205 AFSCcb *pCcb = NULL;
3206 USHORT usFullNameLength = 0;
3207 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3208 UNICODE_STRING uniName;
3210 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3211 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3213 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
3215 ntStatus = STATUS_BUFFER_TOO_SMALL;
3219 RtlZeroMemory( pNameInfo,
3222 usFullNameLength = sizeof( WCHAR) +
3223 AFSServerName.Length +
3224 pCcb->FullFileName.Length;
3226 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
3228 ulCopyLength = (LONG)usFullNameLength;
3232 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3233 ntStatus = STATUS_BUFFER_OVERFLOW;
3236 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
3238 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3240 if( ulCopyLength > 0)
3243 pNameInfo->FileName[ 0] = L'\\';
3244 ulCopyLength -= sizeof( WCHAR);
3246 *Length -= sizeof( WCHAR);
3248 if( ulCopyLength >= AFSServerName.Length)
3251 RtlCopyMemory( &pNameInfo->FileName[ 1],
3252 AFSServerName.Buffer,
3253 AFSServerName.Length);
3255 ulCopyLength -= AFSServerName.Length;
3256 *Length -= AFSServerName.Length;
3258 if( ulCopyLength >= pCcb->FullFileName.Length)
3261 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3262 pCcb->FullFileName.Buffer,
3263 pCcb->FullFileName.Length);
3265 ulCopyLength -= pCcb->FullFileName.Length;
3266 *Length -= pCcb->FullFileName.Length;
3268 uniName.Length = (USHORT)pNameInfo->FileNameLength;
3269 uniName.MaximumLength = uniName.Length;
3270 uniName.Buffer = pNameInfo->FileName;
3275 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3276 pCcb->FullFileName.Buffer,
3279 *Length -= ulCopyLength;
3281 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
3282 uniName.MaximumLength = uniName.Length;
3283 uniName.Buffer = pNameInfo->FileName;
3286 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3287 AFS_TRACE_LEVEL_VERBOSE,
3288 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
3296 case FileInternalInformation:
3299 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3301 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
3304 pInternalInfo->IndexNumber.HighPart = 0;
3306 pInternalInfo->IndexNumber.LowPart = 0;
3308 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
3313 ntStatus = STATUS_BUFFER_TOO_SMALL;
3321 ntStatus = STATUS_INVALID_PARAMETER;
3323 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3324 AFS_TRACE_LEVEL_WARNING,
3325 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
3326 ulFileInformationClass);