2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * - Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
14 * this list of conditions and the following disclaimer in the
16 * and/or other materials provided with the distribution.
17 * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
18 * nor the names of their contributors may be used to endorse or promote
19 * products derived from this software without specific prior written
20 * permission from Kernel Drivers, LLC and Your File System, Inc.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 // File: AFSFileInfo.cpp
39 #include "AFSCommon.h"
42 // Function: AFSQueryFileInfo
46 // This function is the dispatch handler for the IRP_MJ_QUERY_FILE_INFORMATION request
50 // A status is returned for the function
54 AFSQueryFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
58 UNREFERENCED_PARAMETER(LibDeviceObject);
59 NTSTATUS ntStatus = STATUS_SUCCESS;
60 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
63 BOOLEAN bReleaseMain = FALSE;
65 FILE_INFORMATION_CLASS stFileInformationClass;
73 // Determine the type of request this request is
76 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
78 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
83 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
84 AFS_TRACE_LEVEL_ERROR,
85 "AFSQueryFileInfo Attempted access (%p) when pFcb == NULL\n",
88 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
91 lLength = (LONG)pIrpSp->Parameters.QueryFile.Length;
92 stFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
93 pBuffer = Irp->AssociatedIrp.SystemBuffer;
95 if ( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
98 RtlZeroMemory( &stAuthGroup,
101 AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
102 (ULONGLONG)PsGetCurrentThreadId(),
105 ntStatus = AFSVerifyEntry( &stAuthGroup,
108 if ( NT_SUCCESS( ntStatus))
111 ClearFlag( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
116 ntStatus = STATUS_SUCCESS;
121 // Grab the main shared right off the bat
124 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
125 AFS_TRACE_LEVEL_VERBOSE,
126 "AFSQueryFileInfo Acquiring Fcb lock %p SHARED %08lX\n",
127 &pFcb->NPFcb->Resource,
128 PsGetCurrentThread()));
130 AFSAcquireShared( &pFcb->NPFcb->Resource,
136 // Don't allow requests against IOCtl nodes
139 if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
142 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
143 AFS_TRACE_LEVEL_VERBOSE,
144 "AFSQueryFileInfo Processing request against SpecialShare Fcb\n"));
146 ntStatus = AFSProcessShareQueryInfo( Irp,
150 try_return( ntStatus);
152 else if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
154 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
155 AFS_TRACE_LEVEL_VERBOSE,
156 "AFSQueryFileInfo request against PIOCtl Fcb\n"));
158 ntStatus = AFSProcessPIOCtlQueryInfo( Irp,
163 try_return( ntStatus);
166 else if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
168 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
169 AFS_TRACE_LEVEL_VERBOSE,
170 "AFSQueryFileInfo request against Invalid Fcb\n"));
172 try_return( ntStatus = STATUS_ACCESS_DENIED);
176 // Process the request
179 switch( stFileInformationClass)
182 case FileAllInformation:
185 PFILE_ALL_INFORMATION pAllInfo;
188 // For the all information class we'll typecast a local
189 // pointer to the output buffer and then call the
190 // individual routines to fill in the buffer.
193 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
195 ntStatus = AFSQueryBasicInfo( Irp,
197 &pAllInfo->BasicInformation,
200 if( !NT_SUCCESS( ntStatus))
203 try_return( ntStatus);
206 ntStatus = AFSQueryStandardInfo( Irp,
208 &pAllInfo->StandardInformation,
211 if( !NT_SUCCESS( ntStatus))
214 try_return( ntStatus);
217 ntStatus = AFSQueryInternalInfo( Irp,
219 &pAllInfo->InternalInformation,
222 if( !NT_SUCCESS( ntStatus))
225 try_return( ntStatus);
228 ntStatus = AFSQueryEaInfo( Irp,
230 &pAllInfo->EaInformation,
233 if( !NT_SUCCESS( ntStatus))
236 try_return( ntStatus);
239 ntStatus = AFSQueryAccess( Irp,
241 &pAllInfo->AccessInformation,
244 if( !NT_SUCCESS( ntStatus))
247 try_return( ntStatus);
250 ntStatus = AFSQueryPositionInfo( Irp,
252 &pAllInfo->PositionInformation,
255 if( !NT_SUCCESS( ntStatus))
258 try_return( ntStatus);
261 ntStatus = AFSQueryMode( Irp,
263 &pAllInfo->ModeInformation,
266 if( !NT_SUCCESS( ntStatus))
269 try_return( ntStatus);
272 ntStatus = AFSQueryAlignment( Irp,
274 &pAllInfo->AlignmentInformation,
277 if( !NT_SUCCESS( ntStatus))
280 try_return( ntStatus);
283 ntStatus = AFSQueryNameInfo( Irp,
285 &pAllInfo->NameInformation,
288 if( !NT_SUCCESS( ntStatus))
291 try_return( ntStatus);
297 case FileBasicInformation:
300 ntStatus = AFSQueryBasicInfo( Irp,
302 (PFILE_BASIC_INFORMATION)pBuffer,
308 case FileStandardInformation:
311 ntStatus = AFSQueryStandardInfo( Irp,
313 (PFILE_STANDARD_INFORMATION)pBuffer,
319 case FileInternalInformation:
322 ntStatus = AFSQueryInternalInfo( Irp,
324 (PFILE_INTERNAL_INFORMATION)pBuffer,
330 case FileEaInformation:
333 ntStatus = AFSQueryEaInfo( Irp,
335 (PFILE_EA_INFORMATION)pBuffer,
341 case FilePositionInformation:
344 ntStatus = AFSQueryPositionInfo( Irp,
346 (PFILE_POSITION_INFORMATION)pBuffer,
352 case FileNormalizedNameInformation:
353 case FileNameInformation:
356 ntStatus = AFSQueryNameInfo( Irp,
358 (PFILE_NAME_INFORMATION)pBuffer,
364 case FileAlternateNameInformation:
367 ntStatus = AFSQueryShortNameInfo( Irp,
369 (PFILE_NAME_INFORMATION)pBuffer,
375 case FileNetworkOpenInformation:
378 ntStatus = AFSQueryNetworkInfo( Irp,
380 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
386 case FileStreamInformation:
389 ntStatus = AFSQueryStreamInfo( Irp,
391 (FILE_STREAM_INFORMATION *)pBuffer,
398 case FileAttributeTagInformation:
401 ntStatus = AFSQueryAttribTagInfo( Irp,
403 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
409 case FileRemoteProtocolInformation:
412 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
414 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
420 case FileNetworkPhysicalNameInformation:
423 ntStatus = AFSQueryPhysicalNameInfo( Irp,
425 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
433 ntStatus = STATUS_INVALID_PARAMETER;
440 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
445 AFSReleaseResource( &pFcb->NPFcb->Resource);
448 if( !NT_SUCCESS( ntStatus) &&
449 ntStatus != STATUS_INVALID_PARAMETER &&
450 ntStatus != STATUS_BUFFER_OVERFLOW)
454 pCcb->DirectoryCB != NULL)
457 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
458 AFS_TRACE_LEVEL_ERROR,
459 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
460 &pCcb->DirectoryCB->NameInformation.FileName,
461 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
462 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
463 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
464 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
469 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
474 "EXCEPTION - AFSQueryFileInfo\n"));
476 AFSDumpTraceFilesFnc();
478 ntStatus = STATUS_UNSUCCESSFUL;
483 AFSReleaseResource( &pFcb->NPFcb->Resource);
487 AFSCompleteRequest( Irp,
494 // Function: AFSSetFileInfo
498 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
502 // A status is returned for the function
506 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
510 UNREFERENCED_PARAMETER(LibDeviceObject);
511 NTSTATUS ntStatus = STATUS_SUCCESS;
512 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
515 FILE_INFORMATION_CLASS FileInformationClass;
516 BOOLEAN bCanQueueRequest = FALSE;
517 PFILE_OBJECT pFileObject = NULL;
518 BOOLEAN bReleaseMain = FALSE;
519 BOOLEAN bUpdateFileInfo = FALSE;
520 AFSFileID stParentFileId;
525 pFileObject = pIrpSp->FileObject;
527 pFcb = (AFSFcb *)pFileObject->FsContext;
528 pCcb = (AFSCcb *)pFileObject->FsContext2;
533 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
534 AFS_TRACE_LEVEL_ERROR,
535 "AFSSetFileInfo Attempted access (%p) when pFcb == NULL\n",
538 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
541 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
542 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
548 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
549 AFS_TRACE_LEVEL_VERBOSE,
550 "AFSSetFileInfo Acquiring Fcb lock %p EXCL %08lX\n",
551 &pFcb->NPFcb->Resource,
552 PsGetCurrentThread()));
554 AFSAcquireExcl( &pFcb->NPFcb->Resource,
560 // Don't allow requests against IOCtl nodes
563 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
566 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
567 AFS_TRACE_LEVEL_ERROR,
568 "AFSSetFileInfo Failing request against PIOCtl Fcb\n"));
570 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
572 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
575 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
576 AFS_TRACE_LEVEL_VERBOSE,
577 "AFSSetFileInfo Processing request against SpecialShare Fcb\n"));
579 ntStatus = AFSProcessShareSetInfo( Irp,
583 try_return( ntStatus);
586 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.FileSystemAttributes, FILE_READ_ONLY_VOLUME))
589 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
590 AFS_TRACE_LEVEL_ERROR,
591 "AFSSetFileInfo Request failed due to read only volume\n",
594 try_return( ntStatus = STATUS_MEDIA_WRITE_PROTECTED);
597 if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB &&
598 FileInformationClass != FileDispositionInformation)
600 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
601 AFS_TRACE_LEVEL_VERBOSE,
602 "AFSSetFileInfo request against Invalid Fcb\n"));
604 try_return( ntStatus = STATUS_ACCESS_DENIED);
608 // Ensure rename operations are synchronous
611 if( FileInformationClass == FileRenameInformation)
614 bCanQueueRequest = FALSE;
618 // Store away the parent fid
621 RtlZeroMemory( &stParentFileId,
624 if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
627 stParentFileId = pFcb->ObjectInformation->ParentFileId;
631 // Process the request
634 switch( FileInformationClass)
637 case FileBasicInformation:
640 bUpdateFileInfo = TRUE;
642 ntStatus = AFSSetBasicInfo( Irp,
648 case FileDispositionInformation:
651 ntStatus = AFSSetDispositionInfo( Irp,
657 case FileRenameInformation:
660 ntStatus = AFSSetRenameInfo( Irp);
665 case FilePositionInformation:
668 ntStatus = AFSSetPositionInfo( Irp,
674 case FileLinkInformation:
677 ntStatus = AFSSetFileLinkInfo( Irp);
682 case FileAllocationInformation:
685 ntStatus = AFSSetAllocationInfo( Irp,
691 case FileEndOfFileInformation:
694 ntStatus = AFSSetEndOfFileInfo( Irp,
702 ntStatus = STATUS_INVALID_PARAMETER;
712 AFSReleaseResource( &pFcb->NPFcb->Resource);
715 if( NT_SUCCESS( ntStatus) &&
719 ntStatus = AFSUpdateFileInformation( &stParentFileId,
720 pFcb->ObjectInformation,
723 if( !NT_SUCCESS( ntStatus))
726 AFSAcquireExcl( &pFcb->NPFcb->Resource,
730 // Unwind the update and fail the request
733 AFSUnwindFileInfo( pFcb,
736 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
737 AFS_TRACE_LEVEL_ERROR,
738 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
739 &pCcb->DirectoryCB->NameInformation.FileName,
740 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
741 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
742 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
743 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
746 AFSReleaseResource( &pFcb->NPFcb->Resource);
750 if( !NT_SUCCESS( ntStatus))
754 pCcb->DirectoryCB != NULL)
757 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
758 AFS_TRACE_LEVEL_ERROR,
759 "AFSSetFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
760 &pCcb->DirectoryCB->NameInformation.FileName,
761 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
762 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
763 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
764 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
769 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
774 "EXCEPTION - AFSSetFileInfo\n"));
776 AFSDumpTraceFilesFnc();
778 ntStatus = STATUS_UNSUCCESSFUL;
783 AFSReleaseResource( &pFcb->NPFcb->Resource);
787 AFSCompleteRequest( Irp,
794 // Function: AFSQueryBasicInfo
798 // This function is the handler for the query basic information request
802 // A status is returned for the function
806 AFSQueryBasicInfo( IN PIRP Irp,
807 IN AFSDirectoryCB *DirectoryCB,
808 IN OUT PFILE_BASIC_INFORMATION Buffer,
811 NTSTATUS ntStatus = STATUS_SUCCESS;
812 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
813 ULONG ulFileAttribs = 0;
816 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
817 AFSFileInfoCB stFileInfo;
818 AFSDirectoryCB *pParentDirectoryCB = NULL;
819 UNICODE_STRING uniParentPath;
821 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
824 RtlZeroMemory( Buffer,
827 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
829 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
830 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
832 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
835 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
837 AFSRetrieveParentPath( &pCcb->FullFileName,
840 RtlZeroMemory( &stFileInfo,
841 sizeof( AFSFileInfoCB));
844 // Can't hold the Fcb while evaluating the path, leads to lock inversion
847 AFSReleaseResource( &pFcb->NPFcb->Resource);
850 // Its a reparse point regardless of whether the file attributes
851 // can be retrieved for the target.
854 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
857 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
862 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
865 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
873 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
876 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
880 AFSAcquireShared( &pFcb->NPFcb->Resource,
885 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
886 AFS_TRACE_LEVEL_VERBOSE_2,
887 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
888 &pCcb->DirectoryCB->NameInformation.FileName,
889 pCcb->DirectoryCB->ObjectInformation->FileType,
890 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
893 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
894 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
895 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
896 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
897 Buffer->FileAttributes = ulFileAttribs;
899 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
900 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
903 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
905 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
909 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
913 *Length -= sizeof( FILE_BASIC_INFORMATION);
918 ntStatus = STATUS_BUFFER_TOO_SMALL;
925 AFSQueryStandardInfo( IN PIRP Irp,
926 IN AFSDirectoryCB *DirectoryCB,
927 IN OUT PFILE_STANDARD_INFORMATION Buffer,
931 NTSTATUS ntStatus = STATUS_SUCCESS;
934 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
935 AFSFileInfoCB stFileInfo;
936 AFSDirectoryCB *pParentDirectoryCB = NULL;
937 UNICODE_STRING uniParentPath;
938 ULONG ulFileAttribs = 0;
940 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
943 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
944 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
946 RtlZeroMemory( Buffer,
949 Buffer->NumberOfLinks = 1;
950 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
952 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
954 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
956 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
958 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
961 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
963 AFSRetrieveParentPath( &pCcb->FullFileName,
966 RtlZeroMemory( &stFileInfo,
967 sizeof( AFSFileInfoCB));
970 // Can't hold the Fcb while evaluating the path, leads to lock inversion
973 AFSReleaseResource( &pFcb->NPFcb->Resource);
976 // Its a reparse point regardless of whether or not the
977 // file attributes can be retrieved.
980 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
983 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
988 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
991 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
999 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1002 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1006 AFSAcquireShared( &pFcb->NPFcb->Resource,
1010 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
1011 AFS_TRACE_LEVEL_VERBOSE_2,
1012 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1013 &pCcb->DirectoryCB->NameInformation.FileName,
1014 pCcb->DirectoryCB->ObjectInformation->FileType,
1015 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1018 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
1020 *Length -= sizeof( FILE_STANDARD_INFORMATION);
1025 ntStatus = STATUS_BUFFER_TOO_SMALL;
1032 AFSQueryInternalInfo( IN PIRP Irp,
1034 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
1035 IN OUT PLONG Length)
1038 UNREFERENCED_PARAMETER(Irp);
1039 NTSTATUS ntStatus = STATUS_SUCCESS;
1041 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
1044 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Vnode;
1046 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Unique;
1048 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
1053 ntStatus = STATUS_BUFFER_TOO_SMALL;
1060 AFSQueryEaInfo( IN PIRP Irp,
1061 IN AFSDirectoryCB *DirectoryCB,
1062 IN OUT PFILE_EA_INFORMATION Buffer,
1063 IN OUT PLONG Length)
1066 UNREFERENCED_PARAMETER(Irp);
1067 UNREFERENCED_PARAMETER(DirectoryCB);
1068 NTSTATUS ntStatus = STATUS_SUCCESS;
1070 RtlZeroMemory( Buffer,
1073 if( *Length >= sizeof( FILE_EA_INFORMATION))
1078 *Length -= sizeof( FILE_EA_INFORMATION);
1083 ntStatus = STATUS_BUFFER_TOO_SMALL;
1090 AFSQueryPositionInfo( IN PIRP Irp,
1092 IN OUT PFILE_POSITION_INFORMATION Buffer,
1093 IN OUT PLONG Length)
1096 UNREFERENCED_PARAMETER(Fcb);
1097 NTSTATUS ntStatus = STATUS_SUCCESS;
1098 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1100 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1103 RtlZeroMemory( Buffer,
1106 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1108 *Length -= sizeof( FILE_POSITION_INFORMATION);
1113 ntStatus = STATUS_BUFFER_TOO_SMALL;
1120 AFSQueryAccess( IN PIRP Irp,
1122 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1123 IN OUT PLONG Length)
1126 UNREFERENCED_PARAMETER(Irp);
1127 UNREFERENCED_PARAMETER(Fcb);
1128 NTSTATUS ntStatus = STATUS_SUCCESS;
1130 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1133 RtlZeroMemory( Buffer,
1136 Buffer->AccessFlags = 0;
1138 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1143 ntStatus = STATUS_BUFFER_TOO_SMALL;
1150 AFSQueryMode( IN PIRP Irp,
1152 IN OUT PFILE_MODE_INFORMATION Buffer,
1153 IN OUT PLONG Length)
1156 UNREFERENCED_PARAMETER(Irp);
1157 UNREFERENCED_PARAMETER(Fcb);
1158 NTSTATUS ntStatus = STATUS_SUCCESS;
1160 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1163 RtlZeroMemory( Buffer,
1168 *Length -= sizeof( FILE_MODE_INFORMATION);
1173 ntStatus = STATUS_BUFFER_TOO_SMALL;
1180 AFSQueryAlignment( IN PIRP Irp,
1182 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1183 IN OUT PLONG Length)
1186 UNREFERENCED_PARAMETER(Irp);
1187 UNREFERENCED_PARAMETER(Fcb);
1188 NTSTATUS ntStatus = STATUS_SUCCESS;
1190 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1193 RtlZeroMemory( Buffer,
1196 Buffer->AlignmentRequirement = 1;
1198 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1203 ntStatus = STATUS_BUFFER_TOO_SMALL;
1210 AFSQueryNameInfo( IN PIRP Irp,
1211 IN AFSDirectoryCB *DirectoryCB,
1212 IN OUT PFILE_NAME_INFORMATION Buffer,
1213 IN OUT PLONG Length)
1216 UNREFERENCED_PARAMETER(DirectoryCB);
1217 NTSTATUS ntStatus = STATUS_SUCCESS;
1218 ULONG ulCopyLength = 0;
1219 ULONG cchCopied = 0;
1220 AFSFcb *pFcb = NULL;
1221 AFSCcb *pCcb = NULL;
1222 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1223 BOOLEAN bAddLeadingSlash = FALSE;
1224 BOOLEAN bAddTrailingSlash = FALSE;
1225 USHORT usFullNameLength = 0;
1227 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1229 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1231 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1234 RtlZeroMemory( Buffer,
1237 if( pCcb->FullFileName.Length == 0 ||
1238 pCcb->FullFileName.Buffer[ 0] != L'\\')
1240 bAddLeadingSlash = TRUE;
1243 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1244 pCcb->FullFileName.Length > 0 &&
1245 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1247 bAddTrailingSlash = TRUE;
1250 usFullNameLength = sizeof( WCHAR) +
1251 AFSServerName.Length +
1252 pCcb->FullFileName.Length;
1254 if( bAddLeadingSlash)
1256 usFullNameLength += sizeof( WCHAR);
1259 if( bAddTrailingSlash)
1261 usFullNameLength += sizeof( WCHAR);
1264 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1267 ulCopyLength = (LONG)usFullNameLength;
1272 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1274 ntStatus = STATUS_BUFFER_OVERFLOW;
1277 Buffer->FileNameLength = (ULONG)usFullNameLength;
1279 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1281 if( ulCopyLength > 0)
1284 Buffer->FileName[ 0] = L'\\';
1285 ulCopyLength -= sizeof( WCHAR);
1287 *Length -= sizeof( WCHAR);
1290 if( ulCopyLength >= AFSServerName.Length)
1293 RtlCopyMemory( &Buffer->FileName[ 1],
1294 AFSServerName.Buffer,
1295 AFSServerName.Length);
1297 ulCopyLength -= AFSServerName.Length;
1298 *Length -= AFSServerName.Length;
1299 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1301 if ( ulCopyLength > 0 &&
1305 Buffer->FileName[ cchCopied] = L'\\';
1307 ulCopyLength -= sizeof( WCHAR);
1308 *Length -= sizeof( WCHAR);
1312 if( ulCopyLength >= pCcb->FullFileName.Length)
1315 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1316 pCcb->FullFileName.Buffer,
1317 pCcb->FullFileName.Length);
1319 ulCopyLength -= pCcb->FullFileName.Length;
1320 *Length -= pCcb->FullFileName.Length;
1321 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1323 if( ulCopyLength > 0 &&
1326 Buffer->FileName[ cchCopied] = L'\\';
1328 *Length -= sizeof( WCHAR);
1334 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1335 pCcb->FullFileName.Buffer,
1338 *Length -= ulCopyLength;
1346 ntStatus = STATUS_BUFFER_TOO_SMALL;
1353 AFSQueryShortNameInfo( IN PIRP Irp,
1354 IN AFSDirectoryCB *DirectoryCB,
1355 IN OUT PFILE_NAME_INFORMATION Buffer,
1356 IN OUT PLONG Length)
1359 UNREFERENCED_PARAMETER(Irp);
1360 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1361 ULONG ulCopyLength = 0;
1363 RtlZeroMemory( Buffer,
1366 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1370 // The short name IS the long name
1373 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1376 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1379 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1381 ntStatus = STATUS_SUCCESS;
1386 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1388 ntStatus = STATUS_BUFFER_OVERFLOW;
1391 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1393 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1395 if( ulCopyLength > 0)
1398 RtlCopyMemory( Buffer->FileName,
1399 DirectoryCB->NameInformation.FileName.Buffer,
1402 *Length -= ulCopyLength;
1409 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1412 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1415 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1417 ntStatus = STATUS_SUCCESS;
1422 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1424 ntStatus = STATUS_BUFFER_OVERFLOW;
1427 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1429 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1431 if( ulCopyLength > 0)
1434 RtlCopyMemory( Buffer->FileName,
1435 DirectoryCB->NameInformation.ShortName,
1436 Buffer->FileNameLength);
1438 *Length -= ulCopyLength;
1447 AFSQueryNetworkInfo( IN PIRP Irp,
1448 IN AFSDirectoryCB *DirectoryCB,
1449 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1450 IN OUT PLONG Length)
1453 NTSTATUS ntStatus = STATUS_SUCCESS;
1454 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1455 AFSFcb *pFcb = NULL;
1456 AFSCcb *pCcb = NULL;
1457 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1458 AFSFileInfoCB stFileInfo;
1459 AFSDirectoryCB *pParentDirectoryCB = NULL;
1460 UNICODE_STRING uniParentPath;
1461 ULONG ulFileAttribs = 0;
1463 RtlZeroMemory( Buffer,
1466 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1469 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1471 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1472 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1474 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1477 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1479 AFSRetrieveParentPath( &pCcb->FullFileName,
1482 RtlZeroMemory( &stFileInfo,
1483 sizeof( AFSFileInfoCB));
1486 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1489 AFSReleaseResource( &pFcb->NPFcb->Resource);
1492 // Its a reparse point regardless of whether the file attributes
1493 // can be retrieved for the target.
1496 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1499 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1504 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1507 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1515 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1518 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1522 AFSAcquireShared( &pFcb->NPFcb->Resource,
1526 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
1527 AFS_TRACE_LEVEL_VERBOSE_2,
1528 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1529 &pCcb->DirectoryCB->NameInformation.FileName,
1530 pCcb->DirectoryCB->ObjectInformation->FileType,
1531 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1534 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1535 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1536 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1537 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1539 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1540 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1542 Buffer->FileAttributes = ulFileAttribs;
1544 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1545 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1548 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1551 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1556 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1560 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1565 ntStatus = STATUS_BUFFER_TOO_SMALL;
1572 AFSQueryStreamInfo( IN PIRP Irp,
1573 IN AFSDirectoryCB *DirectoryCB,
1574 IN OUT FILE_STREAM_INFORMATION *Buffer,
1575 IN OUT PLONG Length)
1578 UNREFERENCED_PARAMETER(Irp);
1579 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1580 ULONG ulCopyLength = 0;
1582 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1585 RtlZeroMemory( Buffer,
1588 Buffer->NextEntryOffset = 0;
1591 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1594 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1599 ntStatus = STATUS_SUCCESS;
1604 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1606 ntStatus = STATUS_BUFFER_OVERFLOW;
1609 Buffer->StreamNameLength = 14; // ::$DATA
1611 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1613 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1615 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1617 if( ulCopyLength > 0)
1620 RtlCopyMemory( Buffer->StreamName,
1624 *Length -= ulCopyLength;
1630 Buffer->StreamNameLength = 0; // No stream for a directory
1632 // The response size is zero
1634 ntStatus = STATUS_SUCCESS;
1642 AFSQueryAttribTagInfo( IN PIRP Irp,
1643 IN AFSDirectoryCB *DirectoryCB,
1644 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1645 IN OUT PLONG Length)
1648 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1649 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1650 AFSFcb *pFcb = NULL;
1651 AFSCcb *pCcb = NULL;
1652 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1653 AFSFileInfoCB stFileInfo;
1654 AFSDirectoryCB *pParentDirectoryCB = NULL;
1655 UNICODE_STRING uniParentPath;
1656 ULONG ulFileAttribs = 0;
1658 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1661 RtlZeroMemory( Buffer,
1664 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1666 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1667 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1669 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1672 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1674 AFSRetrieveParentPath( &pCcb->FullFileName,
1677 RtlZeroMemory( &stFileInfo,
1678 sizeof( AFSFileInfoCB));
1681 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1684 AFSReleaseResource( &pFcb->NPFcb->Resource);
1687 // Its a reparse point regardless of whether the file attributes
1688 // can be retrieved for the target.
1691 if ( ulFileAttribs == FILE_ATTRIBUTE_NORMAL)
1694 ulFileAttribs = FILE_ATTRIBUTE_REPARSE_POINT;
1699 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1702 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1710 if ( stFileInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1713 ulFileAttribs |= FILE_ATTRIBUTE_DIRECTORY;
1717 AFSAcquireShared( &pFcb->NPFcb->Resource,
1721 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
1722 AFS_TRACE_LEVEL_VERBOSE_2,
1723 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1724 &pCcb->DirectoryCB->NameInformation.FileName,
1725 pCcb->DirectoryCB->ObjectInformation->FileType,
1726 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1729 Buffer->FileAttributes = ulFileAttribs;
1731 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1732 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1735 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1738 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1743 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1747 if ( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1750 Buffer->ReparseTag = IO_REPARSE_TAG_SURROGATE|IO_REPARSE_TAG_OPENAFS_DFS;
1752 else if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1755 Buffer->ReparseTag = IO_REPARSE_TAG_SYMLINK;
1758 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1760 ntStatus = STATUS_SUCCESS;
1767 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1768 IN AFSDirectoryCB *DirectoryCB,
1769 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1770 IN OUT PLONG Length)
1773 UNREFERENCED_PARAMETER(Irp);
1774 UNREFERENCED_PARAMETER(DirectoryCB);
1775 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1777 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1780 RtlZeroMemory( Buffer,
1783 Buffer->StructureVersion = 1;
1785 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1787 Buffer->Protocol = WNNC_NET_OPENAFS;
1789 Buffer->ProtocolMajorVersion = 3;
1791 Buffer->ProtocolMinorVersion = 0;
1793 Buffer->ProtocolRevision = 0;
1795 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1797 ntStatus = STATUS_SUCCESS;
1804 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1805 IN AFSDirectoryCB *DirectoryCB,
1806 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1807 IN OUT PLONG Length)
1810 UNREFERENCED_PARAMETER(DirectoryCB);
1811 NTSTATUS ntStatus = STATUS_SUCCESS;
1812 ULONG ulCopyLength = 0;
1813 ULONG cchCopied = 0;
1814 AFSFcb *pFcb = NULL;
1815 AFSCcb *pCcb = NULL;
1816 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1817 BOOLEAN bAddLeadingSlash = FALSE;
1818 USHORT usFullNameLength = 0;
1820 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1822 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1824 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1827 RtlZeroMemory( Buffer,
1830 if( pCcb->FullFileName.Length == 0 ||
1831 pCcb->FullFileName.Buffer[ 0] != L'\\')
1833 bAddLeadingSlash = TRUE;
1836 usFullNameLength = pCcb->FullFileName.Length;
1838 if( bAddLeadingSlash)
1840 usFullNameLength += sizeof( WCHAR);
1843 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1845 ulCopyLength = (LONG)usFullNameLength;
1850 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1852 ntStatus = STATUS_BUFFER_OVERFLOW;
1855 Buffer->FileNameLength = (ULONG)usFullNameLength;
1857 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1859 if( ulCopyLength > 0)
1862 if( bAddLeadingSlash)
1865 Buffer->FileName[ cchCopied] = L'\\';
1867 ulCopyLength -= sizeof( WCHAR);
1868 *Length -= sizeof( WCHAR);
1872 if( ulCopyLength >= pCcb->FullFileName.Length)
1875 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1876 pCcb->FullFileName.Buffer,
1877 pCcb->FullFileName.Length);
1879 ulCopyLength -= pCcb->FullFileName.Length;
1880 *Length -= pCcb->FullFileName.Length;
1881 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1886 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1887 pCcb->FullFileName.Buffer,
1890 *Length -= ulCopyLength;
1897 ntStatus = STATUS_BUFFER_TOO_SMALL;
1904 AFSSetBasicInfo( IN PIRP Irp,
1905 IN AFSDirectoryCB *DirectoryCB)
1907 NTSTATUS ntStatus = STATUS_SUCCESS;
1908 PFILE_BASIC_INFORMATION pBuffer;
1909 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1910 ULONG ulNotifyFilter = 0;
1911 AFSCcb *pCcb = NULL;
1916 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1918 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1920 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1922 if( pBuffer->FileAttributes != (ULONGLONG)0)
1925 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1926 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1929 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1932 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1935 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1938 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1940 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1942 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1944 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1947 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1949 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1950 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1953 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1955 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1957 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1959 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1962 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1964 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1965 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1968 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1970 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1972 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1974 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1977 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1979 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1980 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1983 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1985 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1987 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1989 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1992 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1994 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1995 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1998 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
2000 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
2002 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
2004 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2007 if( ulNotifyFilter > 0)
2010 if( BooleanFlagOn( DirectoryCB->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2013 AFSObjectInfoCB * pParentObjectInfo = AFSFindObjectInfo( DirectoryCB->ObjectInformation->VolumeCB,
2014 &DirectoryCB->ObjectInformation->ParentFileId);
2016 if ( pParentObjectInfo != NULL)
2018 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
2020 (ULONG)ulNotifyFilter,
2021 (ULONG)FILE_ACTION_MODIFIED);
2023 AFSReleaseObjectInfo( &pParentObjectInfo);
2037 AFSSetDispositionInfo( IN PIRP Irp,
2038 IN AFSDirectoryCB *DirectoryCB)
2040 NTSTATUS ntStatus = STATUS_SUCCESS;
2041 PFILE_DISPOSITION_INFORMATION pBuffer;
2042 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2043 AFSFcb *pFcb = NULL;
2044 AFSCcb *pCcb = NULL;
2049 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2051 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2053 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2056 // Can't delete the root
2059 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2062 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2063 AFS_TRACE_LEVEL_ERROR,
2064 "AFSSetDispositionInfo Attempt to delete root entry\n"));
2066 try_return( ntStatus = STATUS_CANNOT_DELETE);
2070 // If the file is read only then do not allow the delete
2073 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
2076 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2077 AFS_TRACE_LEVEL_ERROR,
2078 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
2079 &DirectoryCB->NameInformation.FileName));
2081 try_return( ntStatus = STATUS_CANNOT_DELETE);
2084 if( pBuffer->DeleteFile)
2088 // Check if the caller can delete the file
2091 ntStatus = AFSNotifyDelete( DirectoryCB,
2095 if( !NT_SUCCESS( ntStatus))
2098 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2099 AFS_TRACE_LEVEL_ERROR,
2100 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
2101 &DirectoryCB->NameInformation.FileName,
2104 try_return( ntStatus);
2107 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2111 // Reduce the Link count in the object information block
2112 // to correspond with the deletion of the directory entry.
2115 pFcb->ObjectInformation->Links--;
2118 // Check if this is a directory that there are not currently other opens
2121 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2124 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2125 AFS_TRACE_LEVEL_ERROR,
2126 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
2127 &DirectoryCB->NameInformation.FileName,
2128 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount));
2130 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2133 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2136 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2137 AFS_TRACE_LEVEL_ERROR,
2138 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2139 &DirectoryCB->NameInformation.FileName));
2141 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2144 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2145 AFS_TRACE_LEVEL_VERBOSE,
2146 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2148 &DirectoryCB->NameInformation.FileName));
2150 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2152 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2156 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2157 AFS_TRACE_LEVEL_VERBOSE,
2158 "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
2159 &pFcb->NPFcb->SectionObjectResource,
2160 PsGetCurrentThread()));
2162 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
2166 // Attempt to flush any outstanding data
2169 bMmFlushed = MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2176 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2177 // deadlock with Trend Micro's Enterprise anti-virus product
2178 // which attempts to open the file which is being deleted.
2181 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2182 AFS_TRACE_LEVEL_VERBOSE,
2183 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2185 &DirectoryCB->NameInformation.FileName));
2187 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2190 // Purge the cache as well
2193 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2196 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2202 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2207 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2208 AFS_TRACE_LEVEL_VERBOSE,
2209 "AFSSetDispositionInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
2210 &pFcb->NPFcb->SectionObjectResource,
2211 PsGetCurrentThread()));
2213 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
2218 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2219 AFS_TRACE_LEVEL_ERROR,
2220 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2221 &DirectoryCB->NameInformation.FileName));
2223 try_return( ntStatus = STATUS_CANNOT_DELETE);
2226 else if( pFcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2227 pFcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2228 pFcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2229 pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
2232 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2233 AFS_TRACE_LEVEL_VERBOSE,
2234 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2236 &DirectoryCB->NameInformation.FileName));
2238 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2244 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2248 // OK, should be good to go, set the flag in the file object
2251 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2262 AFSSetFileLinkInfo( IN PIRP Irp)
2265 NTSTATUS ntStatus = STATUS_SUCCESS;
2266 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2267 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2268 PFILE_LINK_INFORMATION pFileLinkInfo = NULL;
2269 PFILE_OBJECT pSrcFileObj = NULL;
2270 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2271 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL;
2272 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2273 AFSObjectInfoCB *pSrcObject = NULL;
2274 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2275 UNICODE_STRING uniSourceName, uniTargetName;
2276 UNICODE_STRING uniFullTargetName, uniTargetParentName;
2277 BOOLEAN bCommonParent = FALSE;
2278 AFSDirectoryCB *pTargetDirEntry = NULL;
2279 AFSDirectoryCB *pNewTargetDirEntry = NULL;
2281 BOOLEAN bTargetEntryExists = FALSE;
2283 BOOLEAN bReleaseTargetDirLock = FALSE;
2284 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2289 pSrcFileObj = pIrpSp->FileObject;
2291 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2292 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2294 pSrcObject = pSrcFcb->ObjectInformation;
2296 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2299 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2300 &pSrcFcb->ObjectInformation->ParentFileId);
2303 pFileLinkInfo = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2306 // Perform some basic checks to ensure FS integrity
2309 if( pSrcFcb->Header.NodeTypeCode != AFS_FILE_FCB)
2312 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2313 AFS_TRACE_LEVEL_ERROR,
2314 "AFSSetFileLinkInfo Attempt to non-file (INVALID_PARAMETER)\n"));
2316 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2319 if( pTargetFileObj == NULL)
2322 if ( pFileLinkInfo->RootDirectory)
2326 // The target directory is provided by HANDLE
2327 // RootDirectory is only set when the target directory is not the same
2328 // as the source directory.
2330 // AFS only supports hard links within a single directory.
2332 // The IOManager should translate any Handle to a FileObject for us.
2333 // However, the failure to receive a FileObject is treated as a fatal
2337 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2338 AFS_TRACE_LEVEL_ERROR,
2339 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory by handle INVALID_PARAMETER\n",
2340 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2342 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2347 uniFullTargetName.Length = (USHORT)pFileLinkInfo->FileNameLength;
2349 uniFullTargetName.Buffer = (PWSTR)&pFileLinkInfo->FileName;
2351 AFSRetrieveFinalComponent( &uniFullTargetName,
2354 AFSRetrieveParentPath( &uniFullTargetName,
2355 &uniTargetParentName);
2357 if ( uniTargetParentName.Length == 0)
2361 // This is a simple rename. Here the target directory is the same as the source parent directory
2362 // and the name is retrieved from the system buffer information
2365 pTargetParentObject = pSrcParentObject;
2370 // uniTargetParentName contains the directory the renamed object
2371 // will be moved to. Must obtain the TargetParentObject.
2374 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2375 AFS_TRACE_LEVEL_ERROR,
2376 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory %wZ (NOT_SAME_DEVICE)\n",
2377 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2378 &uniFullTargetName));
2380 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2384 pTargetDcb = pTargetParentObject->Fcb;
2390 // So here we have the target directory taken from the targetfile object
2393 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2395 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2397 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2400 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2401 // it is only the target component of the rename operation
2404 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2408 // The quick check to see if they are self linking.
2409 // Do the names match? Only do this where the parent directories are
2413 if( pTargetParentObject == pSrcParentObject)
2416 if( FsRtlAreNamesEqual( &uniTargetName,
2421 try_return( ntStatus = STATUS_SUCCESS);
2424 bCommonParent = TRUE;
2430 // We do not allow cross-volume hard links
2433 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2436 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2437 AFS_TRACE_LEVEL_ERROR,
2438 "AFSSetFileLinkInfo Attempt to link to different volume %wZ\n",
2439 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2441 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2445 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2448 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2451 bReleaseTargetDirLock = TRUE;
2453 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2457 if( pTargetDirEntry == NULL)
2461 // Missed so perform a case insensitive lookup
2464 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2467 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2472 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2473 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2478 // Try the short name
2480 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2486 // Increment our ref count on the dir entry
2489 if( pTargetDirEntry != NULL)
2492 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
2493 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
2495 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2497 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2498 AFS_TRACE_LEVEL_VERBOSE,
2499 "AFSSetFileLinkInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2500 &pTargetDirEntry->NameInformation.FileName,
2505 ASSERT( lCount >= 0);
2507 if( !pFileLinkInfo->ReplaceIfExists)
2510 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2511 AFS_TRACE_LEVEL_ERROR,
2512 "AFSSetFileLinkInfo Attempt to link with target collision %wZ Target %wZ\n",
2513 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2514 &pTargetDirEntry->NameInformation.FileName));
2516 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2519 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2520 AFS_TRACE_LEVEL_ERROR,
2521 "AFSSetFileLinkInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2522 &pTargetDirEntry->NameInformation.FileName,
2527 // Pull the directory entry from the parent
2530 AFSRemoveDirNodeFromParent( pTargetParentObject,
2534 bTargetEntryExists = TRUE;
2538 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2539 AFS_TRACE_LEVEL_VERBOSE,
2540 "AFSSetFileLinkInfo Target does NOT exist, normal linking\n"));
2544 // OK, this is a simple rename. Issue the rename
2545 // request to the service.
2548 ntStatus = AFSNotifyHardLink( pSrcFcb->ObjectInformation,
2549 &pSrcCcb->AuthGroup,
2551 pTargetDcb->ObjectInformation,
2552 pSrcCcb->DirectoryCB,
2554 pFileLinkInfo->ReplaceIfExists,
2555 &pNewTargetDirEntry);
2557 if( ntStatus != STATUS_REPARSE &&
2558 !NT_SUCCESS( ntStatus))
2561 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2562 AFS_TRACE_LEVEL_ERROR,
2563 "AFSSetFileLinkInfo Failed link of %wZ to target %wZ Status %08lX\n",
2564 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2568 try_return( ntStatus);
2571 if ( ntStatus != STATUS_REPARSE)
2574 AFSInsertDirectoryNode( pTargetDcb->ObjectInformation,
2580 // Send notification for the target link file
2583 if( bTargetEntryExists || pNewTargetDirEntry)
2586 ulNotificationAction = FILE_ACTION_MODIFIED;
2591 ulNotificationAction = FILE_ACTION_ADDED;
2594 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
2596 (ULONG)ulNotifyFilter,
2597 (ULONG)ulNotificationAction);
2601 if( !NT_SUCCESS( ntStatus))
2604 if( bTargetEntryExists)
2607 AFSInsertDirectoryNode( pTargetParentObject,
2613 if( pTargetDirEntry != NULL)
2617 // Release DirOpenReferenceCount obtained above
2620 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
2622 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2623 AFS_TRACE_LEVEL_VERBOSE,
2624 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2625 &pTargetDirEntry->NameInformation.FileName,
2630 ASSERT( lCount >= 0);
2633 if( pNewTargetDirEntry != NULL)
2637 // Release DirOpenReferenceCount obtained from AFSNotifyHardLink
2640 lCount = InterlockedDecrement( &pNewTargetDirEntry->DirOpenReferenceCount);
2642 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2643 AFS_TRACE_LEVEL_VERBOSE,
2644 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2645 &pNewTargetDirEntry->NameInformation.FileName,
2650 ASSERT( lCount >= 0);
2653 if( bReleaseTargetDirLock)
2656 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2659 if ( pSrcParentObject != NULL)
2662 AFSReleaseObjectInfo( &pSrcParentObject);
2666 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
2667 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
2670 pTargetParentObject = NULL;
2677 AFSSetRenameInfo( IN PIRP Irp)
2680 NTSTATUS ntStatus = STATUS_SUCCESS;
2681 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2682 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2683 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2684 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2685 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2686 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2687 PFILE_OBJECT pTargetParentFileObj = NULL;
2688 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2689 UNICODE_STRING uniTargetName, uniSourceName, uniTargetParentName;
2690 BOOLEAN bReplaceIfExists = FALSE;
2691 UNICODE_STRING uniShortName;
2692 AFSDirectoryCB *pTargetDirEntry = NULL;
2693 ULONG ulTargetCRC = 0;
2694 BOOLEAN bTargetEntryExists = FALSE;
2695 AFSObjectInfoCB *pSrcObject = NULL;
2696 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2698 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2699 UNICODE_STRING uniFullTargetName;
2700 BOOLEAN bCommonParent = FALSE;
2701 BOOLEAN bReleaseTargetDirLock = FALSE;
2702 BOOLEAN bReleaseSourceDirLock = FALSE;
2703 BOOLEAN bDereferenceTargetParentObject = FALSE;
2704 PERESOURCE pSourceDirLock = NULL;
2710 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2712 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2714 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2715 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2717 pSrcObject = pSrcFcb->ObjectInformation;
2719 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2722 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2723 &pSrcFcb->ObjectInformation->ParentFileId);
2727 // Perform some basic checks to ensure FS integrity
2730 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2734 // Can't rename the root directory
2737 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2738 AFS_TRACE_LEVEL_ERROR,
2739 "AFSSetRenameInfo Attempt to rename root entry\n"));
2741 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2744 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2748 // If there are any open children then fail the rename
2751 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2754 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2755 AFS_TRACE_LEVEL_ERROR,
2756 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2757 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2759 try_return( ntStatus = STATUS_ACCESS_DENIED);
2765 // Extract off the final component name from the Fcb
2768 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2769 uniSourceName.MaximumLength = uniSourceName.Length;
2771 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2774 // Resolve the target fileobject
2777 if( pTargetFileObj == NULL)
2780 if ( pRenameInfo->RootDirectory)
2783 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2784 AFS_TRACE_LEVEL_ERROR,
2785 "AFSSetRenameInfo Handle provided but no FileObject ntStatus INVALID_PARAMETER\n"));
2787 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2792 uniFullTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2794 uniFullTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2796 AFSRetrieveFinalComponent( &uniFullTargetName,
2799 AFSRetrieveParentPath( &uniFullTargetName,
2800 &uniTargetParentName);
2802 if ( uniTargetParentName.Length == 0)
2806 // This is a simple rename. Here the target directory is the same as the source parent directory
2807 // and the name is retrieved from the system buffer information
2810 pTargetParentObject = pSrcParentObject;
2815 // uniTargetParentName contains the directory the renamed object
2816 // will be moved to. Must obtain the TargetParentObject.
2819 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2820 AFS_TRACE_LEVEL_ERROR,
2821 "AFSSetRenameInfo Attempt to move %wZ to %wZ -- not yet supported (NOT_SAME_DEVICE)\n",
2822 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2823 &uniFullTargetName));
2825 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2829 pTargetDcb = pTargetParentObject->Fcb;
2835 // So here we have the target directory taken from the targetfile object
2838 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2840 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2842 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2845 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2846 // it is only the target component of the rename operation
2849 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2853 // The quick check to see if they are not really performing a rename
2854 // Do the names match? Only do this where the parent directories are
2858 if( pTargetParentObject == pSrcParentObject)
2861 if( FsRtlAreNamesEqual( &uniTargetName,
2866 try_return( ntStatus = STATUS_SUCCESS);
2869 bCommonParent = TRUE;
2874 bCommonParent = FALSE;
2878 // We do not allow cross-volume renames to occur
2881 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2884 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2885 AFS_TRACE_LEVEL_ERROR,
2886 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2887 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2889 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2892 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2895 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2898 bReleaseTargetDirLock = TRUE;
2900 if( pTargetParentObject != pSrcParentObject)
2902 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2905 bReleaseSourceDirLock = TRUE;
2907 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2910 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2914 if( pTargetDirEntry == NULL)
2918 // Missed so perform a case insensitive lookup
2921 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2924 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2929 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2930 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2935 // Try the short name
2937 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2943 // Increment our ref count on the dir entry
2946 if( pTargetDirEntry != NULL)
2949 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
2950 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
2952 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2954 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2955 AFS_TRACE_LEVEL_VERBOSE,
2956 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2957 &pTargetDirEntry->NameInformation.FileName,
2962 ASSERT( lCount >= 0);
2964 if( !bReplaceIfExists)
2967 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2968 AFS_TRACE_LEVEL_ERROR,
2969 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2970 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2971 &pTargetDirEntry->NameInformation.FileName));
2973 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2976 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2977 AFS_TRACE_LEVEL_ERROR,
2978 "AFSSetRenameInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2979 &pTargetDirEntry->NameInformation.FileName,
2984 // Pull the directory entry from the parent
2987 AFSRemoveDirNodeFromParent( pTargetParentObject,
2991 bTargetEntryExists = TRUE;
2995 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2996 AFS_TRACE_LEVEL_VERBOSE,
2997 "AFSSetRenameInfo Target does NOT exist, normal rename\n"));
3001 // We need to remove the DirEntry from the parent node, update the index
3002 // and reinsert it into the parent tree. Note that for entries with the
3003 // same parent we do not pull the node from the enumeration list
3006 AFSRemoveDirNodeFromParent( pSrcParentObject,
3007 pSrcCcb->DirectoryCB,
3011 // OK, this is a simple rename. Issue the rename
3012 // request to the service.
3015 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
3016 &pSrcCcb->AuthGroup,
3018 pTargetDcb->ObjectInformation,
3019 pSrcCcb->DirectoryCB,
3023 if( !NT_SUCCESS( ntStatus))
3027 // Attempt to re-insert the directory entry
3030 AFSInsertDirectoryNode( pSrcParentObject,
3031 pSrcCcb->DirectoryCB,
3034 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3035 AFS_TRACE_LEVEL_ERROR,
3036 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
3037 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3041 try_return( ntStatus);
3045 // Set the notification up for the source file
3048 if( pSrcParentObject == pTargetParentObject &&
3049 !bTargetEntryExists)
3052 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
3057 ulNotificationAction = FILE_ACTION_REMOVED;
3060 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
3063 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
3068 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
3071 AFSFsRtlNotifyFullReportChange( pSrcParentObject,
3073 (ULONG)ulNotifyFilter,
3074 (ULONG)ulNotificationAction);
3077 // Update the name in the dir entry.
3080 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
3083 if( !NT_SUCCESS( ntStatus))
3087 // Attempt to re-insert the directory entry
3090 AFSInsertDirectoryNode( pSrcParentObject,
3091 pSrcCcb->DirectoryCB,
3094 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3095 AFS_TRACE_LEVEL_ERROR,
3096 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
3097 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3101 try_return( ntStatus);
3105 // Update the object information block, if needed
3108 if( !AFSIsEqualFID( &pSrcObject->FileId,
3112 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
3116 // Remove the old information entry
3119 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3120 &pSrcObject->TreeEntry);
3122 RtlCopyMemory( &pSrcObject->FileId,
3124 sizeof( AFSFileID));
3127 // Insert the entry into the new object table.
3130 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3132 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3135 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3140 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3141 &pSrcObject->TreeEntry)))
3145 // Lost a race, an ObjectInfo object already exists for this FID.
3146 // Let this copy be garbage collected.
3149 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3153 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3157 // Update the hash values for the name trees.
3160 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3163 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3166 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3167 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3168 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3173 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3174 uniShortName.MaximumLength = uniShortName.Length;
3175 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3177 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3180 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3181 AFS_TRACE_LEVEL_VERBOSE,
3182 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3184 &pSrcCcb->DirectoryCB->NameInformation.FileName));
3189 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3196 // Update the file index for the object in the new parent
3199 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3203 // Re-insert the directory entry
3206 AFSInsertDirectoryNode( pTargetParentObject,
3207 pSrcCcb->DirectoryCB,
3211 // Update the parent pointer in the source object if they are different
3214 if( pSrcParentObject != pTargetParentObject)
3217 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenHandleCount);
3219 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenReferenceCount);
3221 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3223 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3225 lCount = AFSObjectInfoIncrement( pTargetParentObject,
3226 AFS_OBJECT_REFERENCE_CHILD);
3228 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3229 AFS_TRACE_LEVEL_VERBOSE,
3230 "AFSSetRenameInfo Increment count on parent object %p Cnt %d\n",
3231 pTargetParentObject,
3234 lCount = AFSObjectInfoDecrement( pSrcParentObject,
3235 AFS_OBJECT_REFERENCE_CHILD);
3237 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3238 AFS_TRACE_LEVEL_VERBOSE,
3239 "AFSSetRenameInfo Decrement count on parent object %p Cnt %d\n",
3243 pSrcCcb->DirectoryCB->ObjectInformation->ParentFileId = pTargetParentObject->FileId;
3245 SetFlag( pSrcCcb->DirectoryCB->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID);
3247 pSrcParentObject = pTargetParentObject;
3249 ulNotificationAction = FILE_ACTION_ADDED;
3254 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3258 // Now update the notification for the target file
3261 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
3263 (ULONG)ulNotifyFilter,
3264 (ULONG)ulNotificationAction);
3267 // If we performed the rename of the target because it existed, we now need to
3268 // delete the tmp target we created above
3271 if( bTargetEntryExists)
3274 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3275 AFS_TRACE_LEVEL_VERBOSE,
3276 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3278 &pTargetDirEntry->NameInformation.FileName));
3280 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3283 // Try and purge the cache map if this is a file
3286 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3287 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3288 pTargetDirEntry->DirOpenReferenceCount > 1)
3291 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3294 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3296 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3298 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3299 AFS_TRACE_LEVEL_VERBOSE,
3300 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3301 &pTargetDirEntry->NameInformation.FileName,
3306 ASSERT( lCount >= 0);
3309 pTargetDirEntry->NameArrayReferenceCount <= 0)
3312 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3313 AFS_TRACE_LEVEL_VERBOSE,
3314 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3316 &pTargetDirEntry->NameInformation.FileName));
3318 AFSDeleteDirEntry( pTargetParentObject,
3322 pTargetDirEntry = NULL;
3324 if ( pTargetFcb != NULL)
3328 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3329 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3332 if( bReleaseTargetDirLock)
3334 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3336 bReleaseTargetDirLock = FALSE;
3339 if( bReleaseSourceDirLock)
3342 AFSReleaseResource( pSourceDirLock);
3344 bReleaseSourceDirLock = FALSE;
3348 // MmForceSectionClosed() can eventually call back into AFSCleanup
3349 // which will need to acquire Fcb->Resource exclusively. Failure
3350 // to obtain it here before holding the SectionObjectResource will
3351 // permit the locks to be obtained out of order risking a deadlock.
3354 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3355 AFS_TRACE_LEVEL_VERBOSE,
3356 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3357 &pTargetFcb->NPFcb->Resource,
3358 PsGetCurrentThread()));
3360 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3363 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3364 AFS_TRACE_LEVEL_VERBOSE,
3365 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3366 &pTargetFcb->NPFcb->SectionObjectResource,
3367 PsGetCurrentThread()));
3369 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3373 // Close the section in the event it was mapped
3376 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3380 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3381 AFS_TRACE_LEVEL_ERROR,
3382 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3386 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3387 AFS_TRACE_LEVEL_VERBOSE,
3388 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3389 &pTargetFcb->NPFcb->SectionObjectResource,
3390 PsGetCurrentThread()));
3392 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3394 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3395 AFS_TRACE_LEVEL_VERBOSE,
3396 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3397 &pTargetFcb->NPFcb->Resource,
3398 PsGetCurrentThread()));
3400 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3406 if( !NT_SUCCESS( ntStatus))
3409 if( bTargetEntryExists)
3412 ASSERT( pTargetParentObject != NULL);
3414 AFSInsertDirectoryNode( pTargetParentObject,
3420 if( pTargetDirEntry != NULL)
3423 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3425 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3426 AFS_TRACE_LEVEL_VERBOSE,
3427 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3428 &pTargetDirEntry->NameInformation.FileName,
3433 ASSERT( lCount >= 0);
3436 if( bReleaseTargetDirLock)
3439 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3442 if( bReleaseSourceDirLock)
3445 AFSReleaseResource( pSourceDirLock);
3448 if ( bDereferenceTargetParentObject)
3451 ObDereferenceObject( pTargetParentFileObj);
3454 if ( pSrcParentObject != NULL)
3457 AFSReleaseObjectInfo( &pSrcParentObject);
3461 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
3462 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
3465 pTargetParentObject = NULL;
3472 AFSSetPositionInfo( IN PIRP Irp,
3473 IN AFSDirectoryCB *DirectoryCB)
3475 UNREFERENCED_PARAMETER(DirectoryCB);
3476 NTSTATUS ntStatus = STATUS_SUCCESS;
3477 PFILE_POSITION_INFORMATION pBuffer;
3478 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3480 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3482 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3488 AFSSetAllocationInfo( IN PIRP Irp,
3489 IN AFSDirectoryCB *DirectoryCB)
3491 UNREFERENCED_PARAMETER(DirectoryCB);
3492 NTSTATUS ntStatus = STATUS_SUCCESS;
3493 PFILE_ALLOCATION_INFORMATION pBuffer;
3494 BOOLEAN bReleasePaging = FALSE;
3495 BOOLEAN bTellCc = FALSE;
3496 BOOLEAN bTellService = FALSE;
3497 BOOLEAN bUserMapped = FALSE;
3498 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3499 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3500 AFSFcb *pFcb = NULL;
3501 AFSCcb *pCcb = NULL;
3502 LARGE_INTEGER liSaveAlloc;
3503 LARGE_INTEGER liSaveFileSize;
3504 LARGE_INTEGER liSaveVDL;
3506 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3508 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3510 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3513 // save values to put back
3515 liSaveAlloc = pFcb->Header.AllocationSize;
3516 liSaveFileSize = pFcb->Header.FileSize;
3517 liSaveVDL = pFcb->Header.ValidDataLength;
3519 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3520 pIrpSp->Parameters.SetFile.AdvanceOnly)
3522 return STATUS_SUCCESS ;
3525 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3528 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3529 AFS_TRACE_LEVEL_VERBOSE,
3530 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3531 &pFcb->NPFcb->SectionObjectResource,
3532 PsGetCurrentThread()));
3534 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3537 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3538 &pBuffer->AllocationSize);
3540 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3541 AFS_TRACE_LEVEL_VERBOSE,
3542 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3543 &pFcb->NPFcb->SectionObjectResource,
3544 PsGetCurrentThread()));
3546 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3549 // Truncating the file
3554 ntStatus = STATUS_USER_MAPPED_FILE ;
3560 // If this is a truncation we need to grab the paging IO resource.
3563 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3564 AFS_TRACE_LEVEL_VERBOSE,
3565 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3566 &pFcb->NPFcb->PagingResource,
3567 PsGetCurrentThread()));
3569 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3572 bReleasePaging = TRUE;
3575 // Must drop the Fcb Resource. When changing the file size
3576 // a deadlock can occur with Trend Micro's filter if the file
3577 // size is set to zero.
3580 AFSReleaseResource( &pFcb->NPFcb->Resource);
3582 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3584 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3587 // Tell Cc that Allocation is moved.
3591 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3594 // We are pulling the EOF back as well so we need to tell
3597 bTellService = TRUE;
3599 pFcb->Header.FileSize = pBuffer->AllocationSize;
3601 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3609 // Tell Cc if allocation is increased.
3612 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3613 AFS_TRACE_LEVEL_VERBOSE,
3614 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3615 &pFcb->NPFcb->PagingResource,
3616 PsGetCurrentThread()));
3618 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3621 bReleasePaging = TRUE;
3624 // Must drop the Fcb Resource. When changing the file size
3625 // a deadlock can occur with Trend Micro's filter if the file
3626 // size is set to zero.
3629 AFSReleaseResource( &pFcb->NPFcb->Resource);
3631 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3633 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3635 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3639 // Now Tell the server if we have to
3644 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3646 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3647 pFcb->ObjectInformation,
3651 if (NT_SUCCESS(ntStatus))
3654 // Trim extents if we told the service - the update has done an implicit
3655 // trim at the service.
3659 AFSTrimExtents( pFcb,
3660 &pFcb->Header.FileSize);
3663 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3665 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3668 CcIsFileCached( pFileObject))
3670 CcSetFileSizes( pFileObject,
3671 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3677 // Put the saved values back
3679 pFcb->Header.ValidDataLength = liSaveVDL;
3680 pFcb->Header.FileSize = liSaveFileSize;
3681 pFcb->Header.AllocationSize = liSaveAlloc;
3682 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3683 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3689 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3691 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3699 AFSSetEndOfFileInfo( IN PIRP Irp,
3700 IN AFSDirectoryCB *DirectoryCB)
3702 UNREFERENCED_PARAMETER(DirectoryCB);
3703 NTSTATUS ntStatus = STATUS_SUCCESS;
3704 PFILE_END_OF_FILE_INFORMATION pBuffer;
3705 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3706 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3707 LARGE_INTEGER liSaveSize;
3708 LARGE_INTEGER liSaveVDL;
3709 LARGE_INTEGER liSaveAlloc;
3710 BOOLEAN bModified = FALSE;
3711 BOOLEAN bReleasePaging = FALSE;
3712 BOOLEAN bTruncated = FALSE;
3713 BOOLEAN bUserMapped = FALSE;
3714 AFSFcb *pFcb = NULL;
3715 AFSCcb *pCcb = NULL;
3717 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3719 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3721 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3723 liSaveSize = pFcb->Header.FileSize;
3724 liSaveAlloc = pFcb->Header.AllocationSize;
3725 liSaveVDL = pFcb->Header.ValidDataLength;
3727 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3728 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3731 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3734 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3735 AFS_TRACE_LEVEL_VERBOSE,
3736 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3737 &pFcb->NPFcb->SectionObjectResource,
3738 PsGetCurrentThread()));
3740 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3743 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3744 &pBuffer->EndOfFile);
3746 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3747 AFS_TRACE_LEVEL_VERBOSE,
3748 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3749 &pFcb->NPFcb->SectionObjectResource,
3750 PsGetCurrentThread()));
3752 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3754 // Truncating the file
3758 ntStatus = STATUS_USER_MAPPED_FILE;
3764 // If this is a truncation we need to grab the paging
3767 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3768 AFS_TRACE_LEVEL_VERBOSE,
3769 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3770 &pFcb->NPFcb->PagingResource,
3771 PsGetCurrentThread()));
3773 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3776 bReleasePaging = TRUE;
3779 // Must drop the Fcb Resource. When changing the file size
3780 // a deadlock can occur with Trend Micro's filter if the file
3781 // size is set to zero.
3784 AFSReleaseResource( &pFcb->NPFcb->Resource);
3786 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3788 pFcb->Header.FileSize = pBuffer->EndOfFile;
3790 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3792 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3794 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3797 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3809 // extending the file, move EOF
3813 // If this is a truncation we need to grab the paging
3816 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3817 AFS_TRACE_LEVEL_VERBOSE,
3818 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3819 &pFcb->NPFcb->PagingResource,
3820 PsGetCurrentThread()));
3822 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3825 bReleasePaging = TRUE;
3828 // Must drop the Fcb Resource. When changing the file size
3829 // a deadlock can occur with Trend Micro's filter if the file
3830 // size is set to zero.
3833 AFSReleaseResource( &pFcb->NPFcb->Resource);
3835 pFcb->Header.FileSize = pBuffer->EndOfFile;
3837 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3839 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3842 // And Allocation as needed.
3844 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3846 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3856 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3858 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3864 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3866 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3867 pFcb->ObjectInformation,
3870 if( NT_SUCCESS(ntStatus))
3873 // We are now good to go so tell CC.
3875 CcSetFileSizes( pFileObject,
3876 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3879 // And give up those extents
3884 AFSTrimExtents( pFcb,
3885 &pFcb->Header.FileSize);
3890 pFcb->Header.ValidDataLength = liSaveVDL;
3891 pFcb->Header.FileSize = liSaveSize;
3892 pFcb->Header.AllocationSize = liSaveAlloc;
3893 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3894 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3901 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3903 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3911 AFSProcessShareSetInfo( IN IRP *Irp,
3916 UNREFERENCED_PARAMETER(Fcb);
3917 NTSTATUS ntStatus = STATUS_SUCCESS;
3918 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3919 FILE_INFORMATION_CLASS ulFileInformationClass;
3920 void *pPipeInfo = NULL;
3924 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3926 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3927 AFS_TRACE_LEVEL_VERBOSE,
3928 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3929 &Ccb->DirectoryCB->NameInformation.FileName,
3930 ulFileInformationClass));
3932 pPipeInfo = AFSLockSystemBuffer( Irp,
3933 pIrpSp->Parameters.SetFile.Length);
3935 if( pPipeInfo == NULL)
3938 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3939 AFS_TRACE_LEVEL_ERROR,
3940 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3941 &Ccb->DirectoryCB->NameInformation.FileName));
3943 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3947 // Send the request to the service
3950 ntStatus = AFSNotifySetPipeInfo( Ccb,
3951 (ULONG)ulFileInformationClass,
3952 pIrpSp->Parameters.SetFile.Length,
3955 if( !NT_SUCCESS( ntStatus))
3958 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3959 AFS_TRACE_LEVEL_ERROR,
3960 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3961 &Ccb->DirectoryCB->NameInformation.FileName,
3964 try_return( ntStatus);
3967 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3968 AFS_TRACE_LEVEL_VERBOSE,
3969 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3970 &Ccb->DirectoryCB->NameInformation.FileName,
3971 ulFileInformationClass));
3982 AFSProcessShareQueryInfo( IN IRP *Irp,
3987 UNREFERENCED_PARAMETER(Fcb);
3988 NTSTATUS ntStatus = STATUS_SUCCESS;
3989 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3990 FILE_INFORMATION_CLASS ulFileInformationClass;
3991 void *pPipeInfo = NULL;
3996 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3998 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3999 AFS_TRACE_LEVEL_VERBOSE,
4000 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
4001 &Ccb->DirectoryCB->NameInformation.FileName,
4002 ulFileInformationClass));
4004 pPipeInfo = AFSLockSystemBuffer( Irp,
4005 pIrpSp->Parameters.QueryFile.Length);
4007 if( pPipeInfo == NULL)
4010 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4011 AFS_TRACE_LEVEL_ERROR,
4012 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
4013 &Ccb->DirectoryCB->NameInformation.FileName));
4015 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4019 // Send the request to the service
4022 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
4023 (ULONG)ulFileInformationClass,
4024 pIrpSp->Parameters.QueryFile.Length,
4026 (ULONG *)&Irp->IoStatus.Information);
4028 if( !NT_SUCCESS( ntStatus))
4031 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4032 AFS_TRACE_LEVEL_ERROR,
4033 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
4034 &Ccb->DirectoryCB->NameInformation.FileName,
4037 try_return( ntStatus);
4040 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4041 AFS_TRACE_LEVEL_VERBOSE,
4042 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
4043 &Ccb->DirectoryCB->NameInformation.FileName,
4044 ulFileInformationClass));
4055 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
4058 IN OUT LONG *Length)
4061 UNREFERENCED_PARAMETER(Fcb);
4062 UNREFERENCED_PARAMETER(Ccb);
4063 NTSTATUS ntStatus = STATUS_SUCCESS;
4064 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4065 FILE_INFORMATION_CLASS ulFileInformationClass;
4070 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
4072 switch( ulFileInformationClass)
4075 case FileBasicInformation:
4078 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4079 AFS_TRACE_LEVEL_VERBOSE,
4080 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n"));
4082 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
4084 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4086 pBasic->CreationTime.QuadPart = 0;
4087 pBasic->LastAccessTime.QuadPart = 0;
4088 pBasic->ChangeTime.QuadPart = 0;
4089 pBasic->LastWriteTime.QuadPart = 0;
4090 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
4092 *Length -= sizeof( FILE_BASIC_INFORMATION);
4096 ntStatus = STATUS_BUFFER_TOO_SMALL;
4102 case FileStandardInformation:
4105 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4106 AFS_TRACE_LEVEL_VERBOSE,
4107 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n"));
4109 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
4111 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4113 pStandard->NumberOfLinks = 1;
4114 pStandard->DeletePending = 0;
4115 pStandard->AllocationSize.QuadPart = 0;
4116 pStandard->EndOfFile.QuadPart = 0;
4117 pStandard->Directory = 0;
4119 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4123 ntStatus = STATUS_BUFFER_TOO_SMALL;
4129 case FileNormalizedNameInformation:
4130 case FileNameInformation:
4133 ULONG ulCopyLength = 0;
4134 AFSFcb *pFcb = NULL;
4135 AFSCcb *pCcb = NULL;
4136 USHORT usFullNameLength = 0;
4137 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4138 UNICODE_STRING uniName;
4140 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4141 AFS_TRACE_LEVEL_VERBOSE,
4142 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n"));
4144 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4145 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4147 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4149 ntStatus = STATUS_BUFFER_TOO_SMALL;
4153 RtlZeroMemory( pNameInfo,
4156 usFullNameLength = sizeof( WCHAR) +
4157 AFSServerName.Length +
4158 pCcb->FullFileName.Length;
4160 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4162 ulCopyLength = (LONG)usFullNameLength;
4166 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4167 ntStatus = STATUS_BUFFER_OVERFLOW;
4170 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4172 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4174 if( ulCopyLength > 0)
4177 pNameInfo->FileName[ 0] = L'\\';
4178 ulCopyLength -= sizeof( WCHAR);
4180 *Length -= sizeof( WCHAR);
4182 if( ulCopyLength >= AFSServerName.Length)
4185 RtlCopyMemory( &pNameInfo->FileName[ 1],
4186 AFSServerName.Buffer,
4187 AFSServerName.Length);
4189 ulCopyLength -= AFSServerName.Length;
4190 *Length -= AFSServerName.Length;
4192 if( ulCopyLength >= pCcb->FullFileName.Length)
4195 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4196 pCcb->FullFileName.Buffer,
4197 pCcb->FullFileName.Length);
4199 ulCopyLength -= pCcb->FullFileName.Length;
4200 *Length -= pCcb->FullFileName.Length;
4202 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4203 uniName.MaximumLength = uniName.Length;
4204 uniName.Buffer = pNameInfo->FileName;
4209 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4210 pCcb->FullFileName.Buffer,
4213 *Length -= ulCopyLength;
4215 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4216 uniName.MaximumLength = uniName.Length;
4217 uniName.Buffer = pNameInfo->FileName;
4220 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4221 AFS_TRACE_LEVEL_VERBOSE,
4222 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4230 case FileInternalInformation:
4233 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4235 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4236 AFS_TRACE_LEVEL_VERBOSE,
4237 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n"));
4239 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4242 pInternalInfo->IndexNumber.HighPart = 0;
4244 pInternalInfo->IndexNumber.LowPart = 0;
4246 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4251 ntStatus = STATUS_BUFFER_TOO_SMALL;
4257 case FileAllInformation:
4259 ntStatus = STATUS_INVALID_PARAMETER;
4261 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4262 AFS_TRACE_LEVEL_WARNING,
4263 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n"));
4268 case FileEaInformation:
4270 ntStatus = STATUS_INVALID_PARAMETER;
4272 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4273 AFS_TRACE_LEVEL_WARNING,
4274 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n"));
4279 case FilePositionInformation:
4281 ntStatus = STATUS_INVALID_PARAMETER;
4283 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4284 AFS_TRACE_LEVEL_WARNING,
4285 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n"));
4290 case FileAlternateNameInformation:
4292 ntStatus = STATUS_INVALID_PARAMETER;
4294 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4295 AFS_TRACE_LEVEL_WARNING,
4296 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n"));
4301 case FileNetworkOpenInformation:
4303 ntStatus = STATUS_INVALID_PARAMETER;
4305 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4306 AFS_TRACE_LEVEL_WARNING,
4307 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n"));
4312 case FileStreamInformation:
4314 ntStatus = STATUS_INVALID_PARAMETER;
4316 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4317 AFS_TRACE_LEVEL_WARNING,
4318 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n"));
4323 case FileAttributeTagInformation:
4325 ntStatus = STATUS_INVALID_PARAMETER;
4327 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4328 AFS_TRACE_LEVEL_WARNING,
4329 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n"));
4334 case FileRemoteProtocolInformation:
4336 ntStatus = STATUS_INVALID_PARAMETER;
4338 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4339 AFS_TRACE_LEVEL_WARNING,
4340 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n"));
4345 case FileNetworkPhysicalNameInformation:
4347 ntStatus = STATUS_INVALID_PARAMETER;
4349 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4350 AFS_TRACE_LEVEL_WARNING,
4351 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n"));
4358 ntStatus = STATUS_INVALID_PARAMETER;
4360 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4361 AFS_TRACE_LEVEL_WARNING,
4362 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4363 ulFileInformationClass));
4370 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4371 AFS_TRACE_LEVEL_VERBOSE,
4372 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",