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 pFcb->ObjectInformation->FileId.Cell,
462 pFcb->ObjectInformation->FileId.Volume,
463 pFcb->ObjectInformation->FileId.Vnode,
464 pFcb->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 pFcb->ObjectInformation->FileId.Cell,
741 pFcb->ObjectInformation->FileId.Volume,
742 pFcb->ObjectInformation->FileId.Vnode,
743 pFcb->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 pFcb->ObjectInformation->FileId.Cell,
762 pFcb->ObjectInformation->FileId.Volume,
763 pFcb->ObjectInformation->FileId.Vnode,
764 pFcb->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 pFcb->ObjectInformation->FileType,
890 pFcb->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 pFcb->ObjectInformation->FileType,
1015 pFcb->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 pFcb->ObjectInformation->FileType,
1531 pFcb->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 pFcb->ObjectInformation->FileType,
1726 pFcb->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);
2134 // Make sure the directory is enumerated before checking to see if it is empty.
2137 if( !BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
2140 AFSAcquireExcl( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
2143 if( !BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
2146 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2147 AFS_TRACE_LEVEL_VERBOSE,
2148 "AFSSetDispositionInfo Enumerating parent FID %08lX-%08lX-%08lX-%08lX\n",
2149 pFcb->ObjectInformation->FileId.Cell,
2150 pFcb->ObjectInformation->FileId.Volume,
2151 pFcb->ObjectInformation->FileId.Vnode,
2152 pFcb->ObjectInformation->FileId.Unique));
2154 ntStatus = AFSEnumerateDirectory( &pCcb->AuthGroup,
2155 pFcb->ObjectInformation,
2158 if( !NT_SUCCESS( ntStatus))
2161 AFSReleaseResource( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
2163 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2164 AFS_TRACE_LEVEL_ERROR,
2165 "AFSSetDispositionInfo Failed to enumerate parent FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2166 pFcb->ObjectInformation->FileId.Cell,
2167 pFcb->ObjectInformation->FileId.Volume,
2168 pFcb->ObjectInformation->FileId.Vnode,
2169 pFcb->ObjectInformation->FileId.Unique,
2172 try_return( ntStatus);
2176 AFSReleaseResource( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
2179 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2182 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2183 AFS_TRACE_LEVEL_ERROR,
2184 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2185 &DirectoryCB->NameInformation.FileName));
2187 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2190 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2191 AFS_TRACE_LEVEL_VERBOSE,
2192 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2194 &DirectoryCB->NameInformation.FileName));
2196 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2198 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2202 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2203 AFS_TRACE_LEVEL_VERBOSE,
2204 "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
2205 &pFcb->NPFcb->SectionObjectResource,
2206 PsGetCurrentThread()));
2208 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
2212 // Attempt to flush any outstanding data
2215 bMmFlushed = MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2222 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2223 // deadlock with Trend Micro's Enterprise anti-virus product
2224 // which attempts to open the file which is being deleted.
2227 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2228 AFS_TRACE_LEVEL_VERBOSE,
2229 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2231 &DirectoryCB->NameInformation.FileName));
2233 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2236 // Purge the cache as well
2239 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2242 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2248 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2253 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2254 AFS_TRACE_LEVEL_VERBOSE,
2255 "AFSSetDispositionInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
2256 &pFcb->NPFcb->SectionObjectResource,
2257 PsGetCurrentThread()));
2259 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
2264 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2265 AFS_TRACE_LEVEL_ERROR,
2266 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2267 &DirectoryCB->NameInformation.FileName));
2269 try_return( ntStatus = STATUS_CANNOT_DELETE);
2272 else if( pFcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2273 pFcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2274 pFcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2275 pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
2278 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2279 AFS_TRACE_LEVEL_VERBOSE,
2280 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2282 &DirectoryCB->NameInformation.FileName));
2284 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2290 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2294 // OK, should be good to go, set the flag in the file object
2297 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2308 AFSSetFileLinkInfo( IN PIRP Irp)
2311 NTSTATUS ntStatus = STATUS_SUCCESS;
2312 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2313 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2314 PFILE_LINK_INFORMATION pFileLinkInfo = NULL;
2315 PFILE_OBJECT pSrcFileObj = NULL;
2316 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2317 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL;
2318 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2319 AFSObjectInfoCB *pSrcObject = NULL;
2320 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2321 UNICODE_STRING uniSourceName, uniTargetName;
2322 UNICODE_STRING uniFullTargetName, uniTargetParentName;
2323 BOOLEAN bCommonParent = FALSE;
2324 AFSDirectoryCB *pTargetDirEntry = NULL;
2325 AFSDirectoryCB *pNewTargetDirEntry = NULL;
2327 BOOLEAN bTargetEntryExists = FALSE;
2329 BOOLEAN bReleaseTargetDirLock = FALSE;
2330 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2335 pSrcFileObj = pIrpSp->FileObject;
2337 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2338 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2340 pSrcObject = pSrcFcb->ObjectInformation;
2342 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2345 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2346 &pSrcFcb->ObjectInformation->ParentFileId);
2349 if( pSrcParentObject == NULL)
2352 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2353 AFS_TRACE_LEVEL_ERROR,
2354 "AFSSetFileLinkInfo Unable to resolve SrcParentObject (INVALID_PARAMETER)\n"));
2358 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2361 pFileLinkInfo = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2364 // Perform some basic checks to ensure FS integrity
2367 if( pSrcFcb->Header.NodeTypeCode != AFS_FILE_FCB)
2370 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2371 AFS_TRACE_LEVEL_ERROR,
2372 "AFSSetFileLinkInfo Attempt to non-file (INVALID_PARAMETER)\n"));
2374 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2377 if( pTargetFileObj == NULL)
2380 if ( pFileLinkInfo->RootDirectory)
2384 // The target directory is provided by HANDLE
2385 // RootDirectory is only set when the target directory is not the same
2386 // as the source directory.
2388 // AFS only supports hard links within a single directory.
2390 // The IOManager should translate any Handle to a FileObject for us.
2391 // However, the failure to receive a FileObject is treated as a fatal
2395 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2396 AFS_TRACE_LEVEL_ERROR,
2397 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory by handle INVALID_PARAMETER\n",
2398 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2400 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2405 uniFullTargetName.Length = (USHORT)pFileLinkInfo->FileNameLength;
2407 uniFullTargetName.Buffer = (PWSTR)&pFileLinkInfo->FileName;
2409 AFSRetrieveFinalComponent( &uniFullTargetName,
2412 AFSRetrieveParentPath( &uniFullTargetName,
2413 &uniTargetParentName);
2415 if ( uniTargetParentName.Length == 0)
2419 // This is a simple rename. Here the target directory is the same as the source parent directory
2420 // and the name is retrieved from the system buffer information
2423 pTargetParentObject = pSrcParentObject;
2428 // uniTargetParentName contains the directory the renamed object
2429 // will be moved to. Must obtain the TargetParentObject.
2432 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2433 AFS_TRACE_LEVEL_ERROR,
2434 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory %wZ (NOT_SAME_DEVICE)\n",
2435 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2436 &uniFullTargetName));
2438 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2442 pTargetDcb = pTargetParentObject->Fcb;
2448 // So here we have the target directory taken from the targetfile object
2451 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2453 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2455 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2458 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2459 // it is only the target component of the rename operation
2462 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2466 // The quick check to see if they are self linking.
2467 // Do the names match? Only do this where the parent directories are
2471 if( pTargetParentObject == pSrcParentObject)
2474 if( FsRtlAreNamesEqual( &uniTargetName,
2479 try_return( ntStatus = STATUS_SUCCESS);
2482 bCommonParent = TRUE;
2488 // We do not allow cross-volume hard links
2491 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2494 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2495 AFS_TRACE_LEVEL_ERROR,
2496 "AFSSetFileLinkInfo Attempt to link to different volume %wZ\n",
2497 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2499 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2503 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2506 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2509 bReleaseTargetDirLock = TRUE;
2511 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2515 if( pTargetDirEntry == NULL)
2519 // Missed so perform a case insensitive lookup
2522 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2525 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2530 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2531 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2536 // Try the short name
2538 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2544 // Increment our ref count on the dir entry
2547 if( pTargetDirEntry != NULL)
2550 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
2551 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
2553 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2555 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2556 AFS_TRACE_LEVEL_VERBOSE,
2557 "AFSSetFileLinkInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2558 &pTargetDirEntry->NameInformation.FileName,
2563 ASSERT( lCount >= 0);
2565 if( !pFileLinkInfo->ReplaceIfExists)
2568 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2569 AFS_TRACE_LEVEL_ERROR,
2570 "AFSSetFileLinkInfo Attempt to link with target collision %wZ Target %wZ\n",
2571 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2572 &pTargetDirEntry->NameInformation.FileName));
2574 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2577 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2578 AFS_TRACE_LEVEL_ERROR,
2579 "AFSSetFileLinkInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2580 &pTargetDirEntry->NameInformation.FileName,
2585 // Pull the directory entry from the parent
2588 AFSRemoveDirNodeFromParent( pTargetParentObject,
2592 bTargetEntryExists = TRUE;
2596 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2597 AFS_TRACE_LEVEL_VERBOSE,
2598 "AFSSetFileLinkInfo Target does NOT exist, normal linking\n"));
2602 // OK, this is a simple rename. Issue the rename
2603 // request to the service.
2606 ntStatus = AFSNotifyHardLink( pSrcFcb->ObjectInformation,
2607 &pSrcCcb->AuthGroup,
2609 pTargetDcb->ObjectInformation,
2610 pSrcCcb->DirectoryCB,
2612 pFileLinkInfo->ReplaceIfExists,
2613 &pNewTargetDirEntry);
2615 if( ntStatus != STATUS_REPARSE &&
2616 !NT_SUCCESS( ntStatus))
2619 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2620 AFS_TRACE_LEVEL_ERROR,
2621 "AFSSetFileLinkInfo Failed link of %wZ to target %wZ Status %08lX\n",
2622 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2626 try_return( ntStatus);
2629 if ( ntStatus != STATUS_REPARSE)
2632 AFSInsertDirectoryNode( pTargetDcb->ObjectInformation,
2638 // Send notification for the target link file
2641 if( bTargetEntryExists || pNewTargetDirEntry)
2644 ulNotificationAction = FILE_ACTION_MODIFIED;
2649 ulNotificationAction = FILE_ACTION_ADDED;
2652 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
2654 (ULONG)ulNotifyFilter,
2655 (ULONG)ulNotificationAction);
2659 if( !NT_SUCCESS( ntStatus))
2662 if( bTargetEntryExists)
2665 AFSInsertDirectoryNode( pTargetParentObject,
2671 if( pTargetDirEntry != NULL)
2675 // Release DirOpenReferenceCount obtained above
2678 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
2680 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2681 AFS_TRACE_LEVEL_VERBOSE,
2682 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2683 &pTargetDirEntry->NameInformation.FileName,
2688 ASSERT( lCount >= 0);
2691 if( pNewTargetDirEntry != NULL)
2695 // Release DirOpenReferenceCount obtained from AFSNotifyHardLink
2698 lCount = InterlockedDecrement( &pNewTargetDirEntry->DirOpenReferenceCount);
2700 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2701 AFS_TRACE_LEVEL_VERBOSE,
2702 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2703 &pNewTargetDirEntry->NameInformation.FileName,
2708 ASSERT( lCount >= 0);
2711 if( bReleaseTargetDirLock)
2714 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2717 if ( pSrcParentObject != NULL)
2720 AFSReleaseObjectInfo( &pSrcParentObject);
2724 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
2725 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
2728 pTargetParentObject = NULL;
2735 AFSSetRenameInfo( IN PIRP Irp)
2738 NTSTATUS ntStatus = STATUS_SUCCESS;
2739 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2740 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2741 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2742 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2743 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2744 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2745 PFILE_OBJECT pTargetParentFileObj = NULL;
2746 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2747 UNICODE_STRING uniTargetName, uniSourceName, uniTargetParentName;
2748 BOOLEAN bReplaceIfExists = FALSE;
2749 UNICODE_STRING uniShortName;
2750 AFSDirectoryCB *pTargetDirEntry = NULL;
2751 ULONG ulTargetCRC = 0;
2752 BOOLEAN bTargetEntryExists = FALSE;
2753 AFSObjectInfoCB *pSrcObject = NULL;
2754 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2756 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2757 UNICODE_STRING uniFullTargetName;
2758 BOOLEAN bCommonParent = FALSE;
2759 BOOLEAN bReleaseTargetDirLock = FALSE;
2760 BOOLEAN bReleaseSourceDirLock = FALSE;
2761 BOOLEAN bDereferenceTargetParentObject = FALSE;
2762 PERESOURCE pSourceDirLock = NULL;
2768 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2770 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2772 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2773 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2775 pSrcObject = pSrcFcb->ObjectInformation;
2777 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2780 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2781 &pSrcFcb->ObjectInformation->ParentFileId);
2784 if( pSrcParentObject == NULL)
2787 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2788 AFS_TRACE_LEVEL_ERROR,
2789 "AFSSetRenameInfo Unable to resolve SrcParentObject (INVALID_PARAMETER)\n"));
2793 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2797 // Perform some basic checks to ensure FS integrity
2800 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2804 // Can't rename the root directory
2807 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2808 AFS_TRACE_LEVEL_ERROR,
2809 "AFSSetRenameInfo Attempt to rename root entry\n"));
2811 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2814 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2818 // If there are any open children then fail the rename
2821 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2824 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2825 AFS_TRACE_LEVEL_ERROR,
2826 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2827 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2829 try_return( ntStatus = STATUS_ACCESS_DENIED);
2835 // Extract off the final component name from the Fcb
2838 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2839 uniSourceName.MaximumLength = uniSourceName.Length;
2841 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2844 // Resolve the target fileobject
2847 if( pTargetFileObj == NULL)
2850 if ( pRenameInfo->RootDirectory)
2853 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2854 AFS_TRACE_LEVEL_ERROR,
2855 "AFSSetRenameInfo Handle provided but no FileObject ntStatus INVALID_PARAMETER\n"));
2857 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2862 uniFullTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2864 uniFullTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2866 AFSRetrieveFinalComponent( &uniFullTargetName,
2869 AFSRetrieveParentPath( &uniFullTargetName,
2870 &uniTargetParentName);
2872 if ( uniTargetParentName.Length == 0)
2876 // This is a simple rename. Here the target directory is the same as the source parent directory
2877 // and the name is retrieved from the system buffer information
2880 pTargetParentObject = pSrcParentObject;
2885 // uniTargetParentName contains the directory the renamed object
2886 // will be moved to. Must obtain the TargetParentObject.
2889 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2890 AFS_TRACE_LEVEL_ERROR,
2891 "AFSSetRenameInfo Attempt to move %wZ to %wZ -- not yet supported (NOT_SAME_DEVICE)\n",
2892 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2893 &uniFullTargetName));
2895 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2899 pTargetDcb = pTargetParentObject->Fcb;
2905 // So here we have the target directory taken from the targetfile object
2908 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2910 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2912 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2915 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2916 // it is only the target component of the rename operation
2919 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2923 // The quick check to see if they are not really performing a rename
2924 // Do the names match? Only do this where the parent directories are
2928 if( pTargetParentObject == pSrcParentObject)
2931 if( FsRtlAreNamesEqual( &uniTargetName,
2936 try_return( ntStatus = STATUS_SUCCESS);
2939 bCommonParent = TRUE;
2944 bCommonParent = FALSE;
2948 // We do not allow cross-volume renames to occur
2951 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2954 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2955 AFS_TRACE_LEVEL_ERROR,
2956 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2957 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2959 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2962 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2965 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2968 bReleaseTargetDirLock = TRUE;
2970 if( pTargetParentObject != pSrcParentObject)
2972 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2975 bReleaseSourceDirLock = TRUE;
2977 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2980 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2984 if( pTargetDirEntry == NULL)
2988 // Missed so perform a case insensitive lookup
2991 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2994 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2999 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3000 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
3005 // Try the short name
3007 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
3013 // Increment our ref count on the dir entry
3016 if( pTargetDirEntry != NULL)
3019 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
3020 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
3022 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
3024 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3025 AFS_TRACE_LEVEL_VERBOSE,
3026 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
3027 &pTargetDirEntry->NameInformation.FileName,
3032 ASSERT( lCount >= 0);
3034 if( !bReplaceIfExists)
3037 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3038 AFS_TRACE_LEVEL_ERROR,
3039 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
3040 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3041 &pTargetDirEntry->NameInformation.FileName));
3043 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
3046 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3047 AFS_TRACE_LEVEL_ERROR,
3048 "AFSSetRenameInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
3049 &pTargetDirEntry->NameInformation.FileName,
3054 // Pull the directory entry from the parent
3057 AFSRemoveDirNodeFromParent( pTargetParentObject,
3061 bTargetEntryExists = TRUE;
3065 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3066 AFS_TRACE_LEVEL_VERBOSE,
3067 "AFSSetRenameInfo Target does NOT exist, normal rename\n"));
3071 // We need to remove the DirEntry from the parent node, update the index
3072 // and reinsert it into the parent tree. Note that for entries with the
3073 // same parent we do not pull the node from the enumeration list
3076 AFSRemoveDirNodeFromParent( pSrcParentObject,
3077 pSrcCcb->DirectoryCB,
3081 // OK, this is a simple rename. Issue the rename
3082 // request to the service.
3085 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
3086 &pSrcCcb->AuthGroup,
3088 pTargetDcb->ObjectInformation,
3089 pSrcCcb->DirectoryCB,
3093 if( !NT_SUCCESS( ntStatus))
3097 // Attempt to re-insert the directory entry
3100 AFSInsertDirectoryNode( pSrcParentObject,
3101 pSrcCcb->DirectoryCB,
3104 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3105 AFS_TRACE_LEVEL_ERROR,
3106 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
3107 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3111 try_return( ntStatus);
3115 // Set the notification up for the source file
3118 if( pSrcParentObject == pTargetParentObject &&
3119 !bTargetEntryExists)
3122 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
3127 ulNotificationAction = FILE_ACTION_REMOVED;
3130 if( pSrcFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
3133 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
3138 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
3141 AFSFsRtlNotifyFullReportChange( pSrcParentObject,
3143 (ULONG)ulNotifyFilter,
3144 (ULONG)ulNotificationAction);
3147 // Update the name in the dir entry.
3150 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
3153 if( !NT_SUCCESS( ntStatus))
3157 // Attempt to re-insert the directory entry
3160 AFSInsertDirectoryNode( pSrcParentObject,
3161 pSrcCcb->DirectoryCB,
3164 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3165 AFS_TRACE_LEVEL_ERROR,
3166 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
3167 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3171 try_return( ntStatus);
3175 // Update the object information block, if needed
3178 if( !AFSIsEqualFID( &pSrcObject->FileId,
3182 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
3186 // Remove the old information entry
3189 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3190 &pSrcObject->TreeEntry);
3192 RtlCopyMemory( &pSrcObject->FileId,
3194 sizeof( AFSFileID));
3197 // Insert the entry into the new object table.
3200 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3202 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3205 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3210 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3211 &pSrcObject->TreeEntry)))
3215 // Lost a race, an ObjectInfo object already exists for this FID.
3216 // Let this copy be garbage collected.
3219 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3223 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3227 // Update the hash values for the name trees.
3230 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3233 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3236 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3237 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3238 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3243 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3244 uniShortName.MaximumLength = uniShortName.Length;
3245 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3247 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3250 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3251 AFS_TRACE_LEVEL_VERBOSE,
3252 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3254 &pSrcCcb->DirectoryCB->NameInformation.FileName));
3259 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3266 // Update the file index for the object in the new parent
3269 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3273 // Re-insert the directory entry
3276 AFSInsertDirectoryNode( pTargetParentObject,
3277 pSrcCcb->DirectoryCB,
3281 // Update the parent pointer in the source object if they are different
3284 if( pSrcParentObject != pTargetParentObject)
3287 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenHandleCount);
3289 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenReferenceCount);
3291 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3293 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3295 lCount = AFSObjectInfoIncrement( pTargetParentObject,
3296 AFS_OBJECT_REFERENCE_CHILD);
3298 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3299 AFS_TRACE_LEVEL_VERBOSE,
3300 "AFSSetRenameInfo Increment count on parent object %p Cnt %d\n",
3301 pTargetParentObject,
3304 lCount = AFSObjectInfoDecrement( pSrcParentObject,
3305 AFS_OBJECT_REFERENCE_CHILD);
3307 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3308 AFS_TRACE_LEVEL_VERBOSE,
3309 "AFSSetRenameInfo Decrement count on parent object %p Cnt %d\n",
3313 pSrcFcb->ObjectInformation->ParentFileId = pTargetParentObject->FileId;
3315 SetFlag( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID);
3317 ulNotificationAction = FILE_ACTION_ADDED;
3322 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3326 // Now update the notification for the target file
3329 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
3331 (ULONG)ulNotifyFilter,
3332 (ULONG)ulNotificationAction);
3335 // If we performed the rename of the target because it existed, we now need to
3336 // delete the tmp target we created above
3339 if( bTargetEntryExists)
3342 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3343 AFS_TRACE_LEVEL_VERBOSE,
3344 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3346 &pTargetDirEntry->NameInformation.FileName));
3348 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3351 // Try and purge the cache map if this is a file
3354 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3355 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3356 pTargetDirEntry->DirOpenReferenceCount > 1)
3359 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3362 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3364 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3366 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3367 AFS_TRACE_LEVEL_VERBOSE,
3368 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3369 &pTargetDirEntry->NameInformation.FileName,
3374 ASSERT( lCount >= 0);
3377 pTargetDirEntry->NameArrayReferenceCount <= 0)
3380 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3381 AFS_TRACE_LEVEL_VERBOSE,
3382 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3384 &pTargetDirEntry->NameInformation.FileName));
3386 AFSDeleteDirEntry( pTargetParentObject,
3390 pTargetDirEntry = NULL;
3392 if ( pTargetFcb != NULL)
3396 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3397 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3400 if( bReleaseTargetDirLock)
3402 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3404 bReleaseTargetDirLock = FALSE;
3407 if( bReleaseSourceDirLock)
3410 AFSReleaseResource( pSourceDirLock);
3412 bReleaseSourceDirLock = FALSE;
3416 // MmForceSectionClosed() can eventually call back into AFSCleanup
3417 // which will need to acquire Fcb->Resource exclusively. Failure
3418 // to obtain it here before holding the SectionObjectResource will
3419 // permit the locks to be obtained out of order risking a deadlock.
3422 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3423 AFS_TRACE_LEVEL_VERBOSE,
3424 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3425 &pTargetFcb->NPFcb->Resource,
3426 PsGetCurrentThread()));
3428 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3431 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3432 AFS_TRACE_LEVEL_VERBOSE,
3433 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3434 &pTargetFcb->NPFcb->SectionObjectResource,
3435 PsGetCurrentThread()));
3437 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3441 // Close the section in the event it was mapped
3444 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3448 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3449 AFS_TRACE_LEVEL_ERROR,
3450 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3454 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3455 AFS_TRACE_LEVEL_VERBOSE,
3456 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3457 &pTargetFcb->NPFcb->SectionObjectResource,
3458 PsGetCurrentThread()));
3460 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3462 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3463 AFS_TRACE_LEVEL_VERBOSE,
3464 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3465 &pTargetFcb->NPFcb->Resource,
3466 PsGetCurrentThread()));
3468 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3474 if( !NT_SUCCESS( ntStatus))
3477 if( bTargetEntryExists)
3480 ASSERT( pTargetParentObject != NULL);
3482 AFSInsertDirectoryNode( pTargetParentObject,
3488 if( pTargetDirEntry != NULL)
3491 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3493 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3494 AFS_TRACE_LEVEL_VERBOSE,
3495 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3496 &pTargetDirEntry->NameInformation.FileName,
3501 ASSERT( lCount >= 0);
3504 if( bReleaseTargetDirLock)
3507 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3510 if( bReleaseSourceDirLock)
3513 AFSReleaseResource( pSourceDirLock);
3516 if ( bDereferenceTargetParentObject)
3519 ObDereferenceObject( pTargetParentFileObj);
3522 if ( pSrcParentObject != NULL)
3525 AFSReleaseObjectInfo( &pSrcParentObject);
3529 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
3530 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
3533 pTargetParentObject = NULL;
3540 AFSSetPositionInfo( IN PIRP Irp,
3541 IN AFSDirectoryCB *DirectoryCB)
3543 UNREFERENCED_PARAMETER(DirectoryCB);
3544 NTSTATUS ntStatus = STATUS_SUCCESS;
3545 PFILE_POSITION_INFORMATION pBuffer;
3546 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3548 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3550 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3556 AFSSetAllocationInfo( IN PIRP Irp,
3557 IN AFSDirectoryCB *DirectoryCB)
3559 UNREFERENCED_PARAMETER(DirectoryCB);
3560 NTSTATUS ntStatus = STATUS_SUCCESS;
3561 PFILE_ALLOCATION_INFORMATION pBuffer;
3562 BOOLEAN bReleasePaging = FALSE;
3563 BOOLEAN bTellCc = FALSE;
3564 BOOLEAN bTellService = FALSE;
3565 BOOLEAN bUserMapped = FALSE;
3566 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3567 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3568 AFSFcb *pFcb = NULL;
3569 AFSCcb *pCcb = NULL;
3570 LARGE_INTEGER liSaveAlloc;
3571 LARGE_INTEGER liSaveFileSize;
3572 LARGE_INTEGER liSaveVDL;
3574 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3576 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3578 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3581 // save values to put back
3583 liSaveAlloc = pFcb->Header.AllocationSize;
3584 liSaveFileSize = pFcb->Header.FileSize;
3585 liSaveVDL = pFcb->Header.ValidDataLength;
3587 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3588 pIrpSp->Parameters.SetFile.AdvanceOnly)
3590 return STATUS_SUCCESS ;
3593 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3596 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3597 AFS_TRACE_LEVEL_VERBOSE,
3598 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3599 &pFcb->NPFcb->SectionObjectResource,
3600 PsGetCurrentThread()));
3602 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3605 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3606 &pBuffer->AllocationSize);
3608 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3609 AFS_TRACE_LEVEL_VERBOSE,
3610 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3611 &pFcb->NPFcb->SectionObjectResource,
3612 PsGetCurrentThread()));
3614 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3617 // Truncating the file
3622 ntStatus = STATUS_USER_MAPPED_FILE ;
3628 // If this is a truncation we need to grab the paging IO resource.
3631 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3632 AFS_TRACE_LEVEL_VERBOSE,
3633 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3634 &pFcb->NPFcb->PagingResource,
3635 PsGetCurrentThread()));
3637 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3640 bReleasePaging = TRUE;
3643 // Must drop the Fcb Resource. When changing the file size
3644 // a deadlock can occur with Trend Micro's filter if the file
3645 // size is set to zero.
3648 AFSReleaseResource( &pFcb->NPFcb->Resource);
3650 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3652 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3655 // Tell Cc that Allocation is moved.
3659 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3662 // We are pulling the EOF back as well so we need to tell
3665 bTellService = TRUE;
3667 pFcb->Header.FileSize = pBuffer->AllocationSize;
3669 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3677 // Tell Cc if allocation is increased.
3680 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3681 AFS_TRACE_LEVEL_VERBOSE,
3682 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3683 &pFcb->NPFcb->PagingResource,
3684 PsGetCurrentThread()));
3686 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3689 bReleasePaging = TRUE;
3692 // Must drop the Fcb Resource. When changing the file size
3693 // a deadlock can occur with Trend Micro's filter if the file
3694 // size is set to zero.
3697 AFSReleaseResource( &pFcb->NPFcb->Resource);
3699 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3701 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3703 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3707 // Now Tell the server if we have to
3712 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3714 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3715 pFcb->ObjectInformation,
3719 if (NT_SUCCESS(ntStatus))
3722 // Trim extents if we told the service - the update has done an implicit
3723 // trim at the service.
3727 AFSTrimExtents( pFcb,
3728 &pFcb->Header.FileSize);
3731 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3733 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3736 CcIsFileCached( pFileObject))
3738 CcSetFileSizes( pFileObject,
3739 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3745 // Put the saved values back
3747 pFcb->Header.ValidDataLength = liSaveVDL;
3748 pFcb->Header.FileSize = liSaveFileSize;
3749 pFcb->Header.AllocationSize = liSaveAlloc;
3750 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3751 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3757 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3759 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3767 AFSSetEndOfFileInfo( IN PIRP Irp,
3768 IN AFSDirectoryCB *DirectoryCB)
3770 UNREFERENCED_PARAMETER(DirectoryCB);
3771 NTSTATUS ntStatus = STATUS_SUCCESS;
3772 PFILE_END_OF_FILE_INFORMATION pBuffer;
3773 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3774 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3775 LARGE_INTEGER liSaveSize;
3776 LARGE_INTEGER liSaveVDL;
3777 LARGE_INTEGER liSaveAlloc;
3778 BOOLEAN bModified = FALSE;
3779 BOOLEAN bReleasePaging = FALSE;
3780 BOOLEAN bTruncated = FALSE;
3781 BOOLEAN bUserMapped = FALSE;
3782 AFSFcb *pFcb = NULL;
3783 AFSCcb *pCcb = NULL;
3785 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3787 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3789 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3791 liSaveSize = pFcb->Header.FileSize;
3792 liSaveAlloc = pFcb->Header.AllocationSize;
3793 liSaveVDL = pFcb->Header.ValidDataLength;
3795 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3796 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3799 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3802 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3803 AFS_TRACE_LEVEL_VERBOSE,
3804 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3805 &pFcb->NPFcb->SectionObjectResource,
3806 PsGetCurrentThread()));
3808 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3811 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3812 &pBuffer->EndOfFile);
3814 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3815 AFS_TRACE_LEVEL_VERBOSE,
3816 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3817 &pFcb->NPFcb->SectionObjectResource,
3818 PsGetCurrentThread()));
3820 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3822 // Truncating the file
3826 ntStatus = STATUS_USER_MAPPED_FILE;
3832 // If this is a truncation we need to grab the paging
3835 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3836 AFS_TRACE_LEVEL_VERBOSE,
3837 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3838 &pFcb->NPFcb->PagingResource,
3839 PsGetCurrentThread()));
3841 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3844 bReleasePaging = TRUE;
3847 // Must drop the Fcb Resource. When changing the file size
3848 // a deadlock can occur with Trend Micro's filter if the file
3849 // size is set to zero.
3852 AFSReleaseResource( &pFcb->NPFcb->Resource);
3854 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3856 pFcb->Header.FileSize = pBuffer->EndOfFile;
3858 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3860 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3862 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3865 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3877 // extending the file, move EOF
3881 // If this is a truncation we need to grab the paging
3884 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3885 AFS_TRACE_LEVEL_VERBOSE,
3886 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3887 &pFcb->NPFcb->PagingResource,
3888 PsGetCurrentThread()));
3890 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3893 bReleasePaging = TRUE;
3896 // Must drop the Fcb Resource. When changing the file size
3897 // a deadlock can occur with Trend Micro's filter if the file
3898 // size is set to zero.
3901 AFSReleaseResource( &pFcb->NPFcb->Resource);
3903 pFcb->Header.FileSize = pBuffer->EndOfFile;
3905 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3907 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3910 // And Allocation as needed.
3912 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3914 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3924 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3926 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3932 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3934 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3935 pFcb->ObjectInformation,
3938 if( NT_SUCCESS(ntStatus))
3941 // We are now good to go so tell CC.
3943 CcSetFileSizes( pFileObject,
3944 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3947 // And give up those extents
3952 AFSTrimExtents( pFcb,
3953 &pFcb->Header.FileSize);
3958 pFcb->Header.ValidDataLength = liSaveVDL;
3959 pFcb->Header.FileSize = liSaveSize;
3960 pFcb->Header.AllocationSize = liSaveAlloc;
3961 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3962 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3969 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3971 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3979 AFSProcessShareSetInfo( IN IRP *Irp,
3984 UNREFERENCED_PARAMETER(Fcb);
3985 NTSTATUS ntStatus = STATUS_SUCCESS;
3986 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3987 FILE_INFORMATION_CLASS ulFileInformationClass;
3988 void *pPipeInfo = NULL;
3992 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
3994 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
3995 AFS_TRACE_LEVEL_VERBOSE,
3996 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3997 &Ccb->DirectoryCB->NameInformation.FileName,
3998 ulFileInformationClass));
4000 pPipeInfo = AFSLockSystemBuffer( Irp,
4001 pIrpSp->Parameters.SetFile.Length);
4003 if( pPipeInfo == NULL)
4006 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4007 AFS_TRACE_LEVEL_ERROR,
4008 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
4009 &Ccb->DirectoryCB->NameInformation.FileName));
4011 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4015 // Send the request to the service
4018 ntStatus = AFSNotifySetPipeInfo( Ccb,
4019 (ULONG)ulFileInformationClass,
4020 pIrpSp->Parameters.SetFile.Length,
4023 if( !NT_SUCCESS( ntStatus))
4026 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4027 AFS_TRACE_LEVEL_ERROR,
4028 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
4029 &Ccb->DirectoryCB->NameInformation.FileName,
4032 try_return( ntStatus);
4035 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4036 AFS_TRACE_LEVEL_VERBOSE,
4037 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
4038 &Ccb->DirectoryCB->NameInformation.FileName,
4039 ulFileInformationClass));
4050 AFSProcessShareQueryInfo( IN IRP *Irp,
4055 UNREFERENCED_PARAMETER(Fcb);
4056 NTSTATUS ntStatus = STATUS_SUCCESS;
4057 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4058 FILE_INFORMATION_CLASS ulFileInformationClass;
4059 void *pPipeInfo = NULL;
4064 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
4066 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4067 AFS_TRACE_LEVEL_VERBOSE,
4068 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
4069 &Ccb->DirectoryCB->NameInformation.FileName,
4070 ulFileInformationClass));
4072 pPipeInfo = AFSLockSystemBuffer( Irp,
4073 pIrpSp->Parameters.QueryFile.Length);
4075 if( pPipeInfo == NULL)
4078 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4079 AFS_TRACE_LEVEL_ERROR,
4080 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
4081 &Ccb->DirectoryCB->NameInformation.FileName));
4083 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4087 // Send the request to the service
4090 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
4091 (ULONG)ulFileInformationClass,
4092 pIrpSp->Parameters.QueryFile.Length,
4094 (ULONG *)&Irp->IoStatus.Information);
4096 if( !NT_SUCCESS( ntStatus))
4099 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4100 AFS_TRACE_LEVEL_ERROR,
4101 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
4102 &Ccb->DirectoryCB->NameInformation.FileName,
4105 try_return( ntStatus);
4108 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4109 AFS_TRACE_LEVEL_VERBOSE,
4110 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
4111 &Ccb->DirectoryCB->NameInformation.FileName,
4112 ulFileInformationClass));
4123 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
4126 IN OUT LONG *Length)
4129 UNREFERENCED_PARAMETER(Fcb);
4130 UNREFERENCED_PARAMETER(Ccb);
4131 NTSTATUS ntStatus = STATUS_SUCCESS;
4132 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4133 FILE_INFORMATION_CLASS ulFileInformationClass;
4138 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
4140 switch( ulFileInformationClass)
4143 case FileBasicInformation:
4146 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4147 AFS_TRACE_LEVEL_VERBOSE,
4148 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n"));
4150 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
4152 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4154 pBasic->CreationTime.QuadPart = 0;
4155 pBasic->LastAccessTime.QuadPart = 0;
4156 pBasic->ChangeTime.QuadPart = 0;
4157 pBasic->LastWriteTime.QuadPart = 0;
4158 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
4160 *Length -= sizeof( FILE_BASIC_INFORMATION);
4164 ntStatus = STATUS_BUFFER_TOO_SMALL;
4170 case FileStandardInformation:
4173 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4174 AFS_TRACE_LEVEL_VERBOSE,
4175 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n"));
4177 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
4179 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4181 pStandard->NumberOfLinks = 1;
4182 pStandard->DeletePending = 0;
4183 pStandard->AllocationSize.QuadPart = 0;
4184 pStandard->EndOfFile.QuadPart = 0;
4185 pStandard->Directory = 0;
4187 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4191 ntStatus = STATUS_BUFFER_TOO_SMALL;
4197 case FileNormalizedNameInformation:
4198 case FileNameInformation:
4201 ULONG ulCopyLength = 0;
4202 AFSFcb *pFcb = NULL;
4203 AFSCcb *pCcb = NULL;
4204 USHORT usFullNameLength = 0;
4205 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4206 UNICODE_STRING uniName;
4208 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4209 AFS_TRACE_LEVEL_VERBOSE,
4210 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n"));
4212 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4213 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4215 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4217 ntStatus = STATUS_BUFFER_TOO_SMALL;
4221 RtlZeroMemory( pNameInfo,
4224 usFullNameLength = sizeof( WCHAR) +
4225 AFSServerName.Length +
4226 pCcb->FullFileName.Length;
4228 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4230 ulCopyLength = (LONG)usFullNameLength;
4234 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4235 ntStatus = STATUS_BUFFER_OVERFLOW;
4238 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4240 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4242 if( ulCopyLength > 0)
4245 pNameInfo->FileName[ 0] = L'\\';
4246 ulCopyLength -= sizeof( WCHAR);
4248 *Length -= sizeof( WCHAR);
4250 if( ulCopyLength >= AFSServerName.Length)
4253 RtlCopyMemory( &pNameInfo->FileName[ 1],
4254 AFSServerName.Buffer,
4255 AFSServerName.Length);
4257 ulCopyLength -= AFSServerName.Length;
4258 *Length -= AFSServerName.Length;
4260 if( ulCopyLength >= pCcb->FullFileName.Length)
4263 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4264 pCcb->FullFileName.Buffer,
4265 pCcb->FullFileName.Length);
4267 ulCopyLength -= pCcb->FullFileName.Length;
4268 *Length -= pCcb->FullFileName.Length;
4270 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4271 uniName.MaximumLength = uniName.Length;
4272 uniName.Buffer = pNameInfo->FileName;
4277 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4278 pCcb->FullFileName.Buffer,
4281 *Length -= ulCopyLength;
4283 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4284 uniName.MaximumLength = uniName.Length;
4285 uniName.Buffer = pNameInfo->FileName;
4288 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4289 AFS_TRACE_LEVEL_VERBOSE,
4290 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4298 case FileInternalInformation:
4301 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4303 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4304 AFS_TRACE_LEVEL_VERBOSE,
4305 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n"));
4307 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4310 pInternalInfo->IndexNumber.HighPart = 0;
4312 pInternalInfo->IndexNumber.LowPart = 0;
4314 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4319 ntStatus = STATUS_BUFFER_TOO_SMALL;
4325 case FileAllInformation:
4327 ntStatus = STATUS_INVALID_PARAMETER;
4329 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4330 AFS_TRACE_LEVEL_WARNING,
4331 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n"));
4336 case FileEaInformation:
4338 ntStatus = STATUS_INVALID_PARAMETER;
4340 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4341 AFS_TRACE_LEVEL_WARNING,
4342 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n"));
4347 case FilePositionInformation:
4349 ntStatus = STATUS_INVALID_PARAMETER;
4351 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4352 AFS_TRACE_LEVEL_WARNING,
4353 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n"));
4358 case FileAlternateNameInformation:
4360 ntStatus = STATUS_INVALID_PARAMETER;
4362 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4363 AFS_TRACE_LEVEL_WARNING,
4364 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n"));
4369 case FileNetworkOpenInformation:
4371 ntStatus = STATUS_INVALID_PARAMETER;
4373 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4374 AFS_TRACE_LEVEL_WARNING,
4375 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n"));
4380 case FileStreamInformation:
4382 ntStatus = STATUS_INVALID_PARAMETER;
4384 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4385 AFS_TRACE_LEVEL_WARNING,
4386 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n"));
4391 case FileAttributeTagInformation:
4393 ntStatus = STATUS_INVALID_PARAMETER;
4395 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4396 AFS_TRACE_LEVEL_WARNING,
4397 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n"));
4402 case FileRemoteProtocolInformation:
4404 ntStatus = STATUS_INVALID_PARAMETER;
4406 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4407 AFS_TRACE_LEVEL_WARNING,
4408 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n"));
4413 case FileNetworkPhysicalNameInformation:
4415 ntStatus = STATUS_INVALID_PARAMETER;
4417 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4418 AFS_TRACE_LEVEL_WARNING,
4419 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n"));
4426 ntStatus = STATUS_INVALID_PARAMETER;
4428 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4429 AFS_TRACE_LEVEL_WARNING,
4430 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4431 ulFileInformationClass));
4438 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4439 AFS_TRACE_LEVEL_VERBOSE,
4440 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",