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,
2017 if ( pParentObjectInfo != NULL)
2019 AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
2021 (ULONG)ulNotifyFilter,
2022 (ULONG)FILE_ACTION_MODIFIED);
2024 AFSReleaseObjectInfo( &pParentObjectInfo);
2038 AFSSetDispositionInfo( IN PIRP Irp,
2039 IN AFSDirectoryCB *DirectoryCB)
2041 NTSTATUS ntStatus = STATUS_SUCCESS;
2042 PFILE_DISPOSITION_INFORMATION pBuffer;
2043 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2044 AFSFcb *pFcb = NULL;
2045 AFSCcb *pCcb = NULL;
2050 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2052 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2054 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2057 // Can't delete the root
2060 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2063 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2064 AFS_TRACE_LEVEL_ERROR,
2065 "AFSSetDispositionInfo Attempt to delete root entry\n"));
2067 try_return( ntStatus = STATUS_CANNOT_DELETE);
2071 // If the file is read only then do not allow the delete
2074 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
2077 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2078 AFS_TRACE_LEVEL_ERROR,
2079 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
2080 &DirectoryCB->NameInformation.FileName));
2082 try_return( ntStatus = STATUS_CANNOT_DELETE);
2085 if( pBuffer->DeleteFile)
2089 // Check if the caller can delete the file
2092 ntStatus = AFSNotifyDelete( DirectoryCB,
2096 if( !NT_SUCCESS( ntStatus))
2099 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2100 AFS_TRACE_LEVEL_ERROR,
2101 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
2102 &DirectoryCB->NameInformation.FileName,
2105 try_return( ntStatus);
2108 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2112 // Reduce the Link count in the object information block
2113 // to correspond with the deletion of the directory entry.
2116 pFcb->ObjectInformation->Links--;
2119 // Check if this is a directory that there are not currently other opens
2122 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2125 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2126 AFS_TRACE_LEVEL_ERROR,
2127 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
2128 &DirectoryCB->NameInformation.FileName,
2129 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount));
2131 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2135 // Make sure the directory is enumerated before checking to see if it is empty.
2138 if( !BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
2141 AFSAcquireExcl( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
2144 if( !BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
2147 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2148 AFS_TRACE_LEVEL_VERBOSE,
2149 "AFSSetDispositionInfo Enumerating parent FID %08lX-%08lX-%08lX-%08lX\n",
2150 pFcb->ObjectInformation->FileId.Cell,
2151 pFcb->ObjectInformation->FileId.Volume,
2152 pFcb->ObjectInformation->FileId.Vnode,
2153 pFcb->ObjectInformation->FileId.Unique));
2155 ntStatus = AFSEnumerateDirectory( &pCcb->AuthGroup,
2156 pFcb->ObjectInformation,
2159 if( !NT_SUCCESS( ntStatus))
2162 AFSReleaseResource( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
2164 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2165 AFS_TRACE_LEVEL_ERROR,
2166 "AFSSetDispositionInfo Failed to enumerate parent FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2167 pFcb->ObjectInformation->FileId.Cell,
2168 pFcb->ObjectInformation->FileId.Volume,
2169 pFcb->ObjectInformation->FileId.Vnode,
2170 pFcb->ObjectInformation->FileId.Unique,
2173 try_return( ntStatus);
2177 AFSReleaseResource( pFcb->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
2180 if( !AFSIsDirectoryEmptyForDelete( pFcb))
2183 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2184 AFS_TRACE_LEVEL_ERROR,
2185 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
2186 &DirectoryCB->NameInformation.FileName));
2188 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
2191 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2192 AFS_TRACE_LEVEL_VERBOSE,
2193 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2195 &DirectoryCB->NameInformation.FileName));
2197 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2199 else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
2203 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2204 AFS_TRACE_LEVEL_VERBOSE,
2205 "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
2206 &pFcb->NPFcb->SectionObjectResource,
2207 PsGetCurrentThread()));
2209 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
2213 // Attempt to flush any outstanding data
2216 bMmFlushed = MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
2223 // Set PENDING_DELETE before CcPurgeCacheSection to avoid a
2224 // deadlock with Trend Micro's Enterprise anti-virus product
2225 // which attempts to open the file which is being deleted.
2228 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2229 AFS_TRACE_LEVEL_VERBOSE,
2230 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2232 &DirectoryCB->NameInformation.FileName));
2234 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2237 // Purge the cache as well
2240 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2243 if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2249 SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2254 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
2255 AFS_TRACE_LEVEL_VERBOSE,
2256 "AFSSetDispositionInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
2257 &pFcb->NPFcb->SectionObjectResource,
2258 PsGetCurrentThread()));
2260 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
2265 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2266 AFS_TRACE_LEVEL_ERROR,
2267 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
2268 &DirectoryCB->NameInformation.FileName));
2270 try_return( ntStatus = STATUS_CANNOT_DELETE);
2273 else if( pFcb->Header.NodeTypeCode == AFS_SYMBOLIC_LINK_FCB ||
2274 pFcb->Header.NodeTypeCode == AFS_MOUNT_POINT_FCB ||
2275 pFcb->Header.NodeTypeCode == AFS_DFS_LINK_FCB ||
2276 pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
2279 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2280 AFS_TRACE_LEVEL_VERBOSE,
2281 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2283 &DirectoryCB->NameInformation.FileName));
2285 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2291 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2295 // OK, should be good to go, set the flag in the file object
2298 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2309 AFSSetFileLinkInfo( IN PIRP Irp)
2312 NTSTATUS ntStatus = STATUS_SUCCESS;
2313 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2314 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2315 PFILE_LINK_INFORMATION pFileLinkInfo = NULL;
2316 PFILE_OBJECT pSrcFileObj = NULL;
2317 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2318 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL;
2319 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2320 AFSObjectInfoCB *pSrcObject = NULL;
2321 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2322 UNICODE_STRING uniSourceName, uniTargetName;
2323 UNICODE_STRING uniFullTargetName, uniTargetParentName;
2324 BOOLEAN bCommonParent = FALSE;
2325 AFSDirectoryCB *pTargetDirEntry = NULL;
2326 AFSDirectoryCB *pNewTargetDirEntry = NULL;
2328 BOOLEAN bTargetEntryExists = FALSE;
2330 BOOLEAN bReleaseTargetDirLock = FALSE;
2331 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2336 pSrcFileObj = pIrpSp->FileObject;
2338 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2339 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2341 pSrcObject = pSrcFcb->ObjectInformation;
2343 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2346 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2347 &pSrcFcb->ObjectInformation->ParentFileId,
2351 if( pSrcParentObject == NULL)
2354 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2355 AFS_TRACE_LEVEL_ERROR,
2356 "AFSSetFileLinkInfo Unable to resolve SrcParentObject (INVALID_PARAMETER)\n"));
2360 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2363 pFileLinkInfo = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2366 // Perform some basic checks to ensure FS integrity
2369 if( pSrcFcb->Header.NodeTypeCode != AFS_FILE_FCB)
2372 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2373 AFS_TRACE_LEVEL_ERROR,
2374 "AFSSetFileLinkInfo Attempt to non-file (INVALID_PARAMETER)\n"));
2376 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2379 if( pTargetFileObj == NULL)
2382 if ( pFileLinkInfo->RootDirectory)
2386 // The target directory is provided by HANDLE
2387 // RootDirectory is only set when the target directory is not the same
2388 // as the source directory.
2390 // AFS only supports hard links within a single directory.
2392 // The IOManager should translate any Handle to a FileObject for us.
2393 // However, the failure to receive a FileObject is treated as a fatal
2397 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2398 AFS_TRACE_LEVEL_ERROR,
2399 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory by handle INVALID_PARAMETER\n",
2400 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2402 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2407 uniFullTargetName.Length = (USHORT)pFileLinkInfo->FileNameLength;
2409 uniFullTargetName.Buffer = (PWSTR)&pFileLinkInfo->FileName;
2411 AFSRetrieveFinalComponent( &uniFullTargetName,
2414 AFSRetrieveParentPath( &uniFullTargetName,
2415 &uniTargetParentName);
2417 if ( uniTargetParentName.Length == 0)
2421 // This is a simple rename. Here the target directory is the same as the source parent directory
2422 // and the name is retrieved from the system buffer information
2425 pTargetParentObject = pSrcParentObject;
2430 // uniTargetParentName contains the directory the renamed object
2431 // will be moved to. Must obtain the TargetParentObject.
2434 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2435 AFS_TRACE_LEVEL_ERROR,
2436 "AFSSetFileLinkInfo Attempt to link %wZ to alternate directory %wZ (NOT_SAME_DEVICE)\n",
2437 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2438 &uniFullTargetName));
2440 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2444 pTargetDcb = pTargetParentObject->Fcb;
2450 // So here we have the target directory taken from the targetfile object
2453 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2455 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2457 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2460 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2461 // it is only the target component of the rename operation
2464 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2468 // The quick check to see if they are self linking.
2469 // Do the names match? Only do this where the parent directories are
2473 if( pTargetParentObject == pSrcParentObject)
2476 if( FsRtlAreNamesEqual( &uniTargetName,
2481 try_return( ntStatus = STATUS_SUCCESS);
2484 bCommonParent = TRUE;
2490 // We do not allow cross-volume hard links
2493 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2496 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2497 AFS_TRACE_LEVEL_ERROR,
2498 "AFSSetFileLinkInfo Attempt to link to different volume %wZ\n",
2499 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2501 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2505 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2508 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2511 bReleaseTargetDirLock = TRUE;
2513 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2517 if( pTargetDirEntry == NULL)
2521 // Missed so perform a case insensitive lookup
2524 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2527 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2532 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
2533 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2538 // Try the short name
2540 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2546 // Increment our ref count on the dir entry
2549 if( pTargetDirEntry != NULL)
2552 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
2553 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
2555 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
2557 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2558 AFS_TRACE_LEVEL_VERBOSE,
2559 "AFSSetFileLinkInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
2560 &pTargetDirEntry->NameInformation.FileName,
2565 ASSERT( lCount >= 0);
2567 if( !pFileLinkInfo->ReplaceIfExists)
2570 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2571 AFS_TRACE_LEVEL_ERROR,
2572 "AFSSetFileLinkInfo Attempt to link with target collision %wZ Target %wZ\n",
2573 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2574 &pTargetDirEntry->NameInformation.FileName));
2576 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2579 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2580 AFS_TRACE_LEVEL_ERROR,
2581 "AFSSetFileLinkInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
2582 &pTargetDirEntry->NameInformation.FileName,
2587 // Pull the directory entry from the parent
2590 AFSRemoveDirNodeFromParent( pTargetParentObject,
2594 bTargetEntryExists = TRUE;
2598 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2599 AFS_TRACE_LEVEL_VERBOSE,
2600 "AFSSetFileLinkInfo Target does NOT exist, normal linking\n"));
2604 // OK, this is a simple rename. Issue the rename
2605 // request to the service.
2608 ntStatus = AFSNotifyHardLink( pSrcFcb->ObjectInformation,
2609 &pSrcCcb->AuthGroup,
2611 pTargetDcb->ObjectInformation,
2612 pSrcCcb->DirectoryCB,
2614 pFileLinkInfo->ReplaceIfExists,
2615 &pNewTargetDirEntry);
2617 if( ntStatus != STATUS_REPARSE &&
2618 !NT_SUCCESS( ntStatus))
2621 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2622 AFS_TRACE_LEVEL_ERROR,
2623 "AFSSetFileLinkInfo Failed link of %wZ to target %wZ Status %08lX\n",
2624 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2628 try_return( ntStatus);
2631 if ( ntStatus != STATUS_REPARSE)
2634 AFSInsertDirectoryNode( pTargetDcb->ObjectInformation,
2640 // Send notification for the target link file
2643 if( bTargetEntryExists || pNewTargetDirEntry)
2646 ulNotificationAction = FILE_ACTION_MODIFIED;
2651 ulNotificationAction = FILE_ACTION_ADDED;
2654 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
2656 (ULONG)ulNotifyFilter,
2657 (ULONG)ulNotificationAction);
2661 if( !NT_SUCCESS( ntStatus))
2664 if( bTargetEntryExists)
2667 AFSInsertDirectoryNode( pTargetParentObject,
2673 if( pTargetDirEntry != NULL)
2677 // Release DirOpenReferenceCount obtained above
2680 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
2682 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2683 AFS_TRACE_LEVEL_VERBOSE,
2684 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2685 &pTargetDirEntry->NameInformation.FileName,
2690 ASSERT( lCount >= 0);
2693 if( pNewTargetDirEntry != NULL)
2697 // Release DirOpenReferenceCount obtained from AFSNotifyHardLink
2700 lCount = InterlockedDecrement( &pNewTargetDirEntry->DirOpenReferenceCount);
2702 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
2703 AFS_TRACE_LEVEL_VERBOSE,
2704 "AFSSetFileLinkInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
2705 &pNewTargetDirEntry->NameInformation.FileName,
2710 ASSERT( lCount >= 0);
2713 if( bReleaseTargetDirLock)
2716 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2719 if ( pSrcParentObject != NULL)
2722 AFSReleaseObjectInfo( &pSrcParentObject);
2726 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
2727 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
2730 pTargetParentObject = NULL;
2737 AFSSetRenameInfo( IN PIRP Irp)
2740 NTSTATUS ntStatus = STATUS_SUCCESS;
2741 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2742 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2743 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2744 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2745 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2746 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2747 PFILE_OBJECT pTargetParentFileObj = NULL;
2748 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2749 UNICODE_STRING uniTargetName, uniSourceName, uniTargetParentName;
2750 BOOLEAN bReplaceIfExists = FALSE;
2751 UNICODE_STRING uniShortName;
2752 AFSDirectoryCB *pTargetDirEntry = NULL;
2753 ULONG ulTargetCRC = 0;
2754 BOOLEAN bTargetEntryExists = FALSE;
2755 AFSObjectInfoCB *pSrcObject = NULL;
2756 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2758 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2759 UNICODE_STRING uniFullTargetName;
2760 BOOLEAN bCommonParent = FALSE;
2761 BOOLEAN bReleaseTargetDirLock = FALSE;
2762 BOOLEAN bReleaseSourceDirLock = FALSE;
2763 BOOLEAN bDereferenceTargetParentObject = FALSE;
2764 PERESOURCE pSourceDirLock = NULL;
2770 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2772 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2774 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2775 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2777 pSrcObject = pSrcFcb->ObjectInformation;
2779 if ( BooleanFlagOn( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
2782 pSrcParentObject = AFSFindObjectInfo( pSrcFcb->ObjectInformation->VolumeCB,
2783 &pSrcFcb->ObjectInformation->ParentFileId,
2787 if( pSrcParentObject == NULL)
2790 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2791 AFS_TRACE_LEVEL_ERROR,
2792 "AFSSetRenameInfo Unable to resolve SrcParentObject (INVALID_PARAMETER)\n"));
2796 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2800 // Perform some basic checks to ensure FS integrity
2803 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2807 // Can't rename the root directory
2810 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2811 AFS_TRACE_LEVEL_ERROR,
2812 "AFSSetRenameInfo Attempt to rename root entry\n"));
2814 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2817 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2821 // If there are any open children then fail the rename
2824 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2827 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2828 AFS_TRACE_LEVEL_ERROR,
2829 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2830 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2832 try_return( ntStatus = STATUS_ACCESS_DENIED);
2838 // Extract off the final component name from the Fcb
2841 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2842 uniSourceName.MaximumLength = uniSourceName.Length;
2844 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2847 // Resolve the target fileobject
2850 if( pTargetFileObj == NULL)
2853 if ( pRenameInfo->RootDirectory)
2856 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2857 AFS_TRACE_LEVEL_ERROR,
2858 "AFSSetRenameInfo Handle provided but no FileObject ntStatus INVALID_PARAMETER\n"));
2860 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2865 uniFullTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2867 uniFullTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2869 AFSRetrieveFinalComponent( &uniFullTargetName,
2872 AFSRetrieveParentPath( &uniFullTargetName,
2873 &uniTargetParentName);
2875 if ( uniTargetParentName.Length == 0)
2879 // This is a simple rename. Here the target directory is the same as the source parent directory
2880 // and the name is retrieved from the system buffer information
2883 pTargetParentObject = pSrcParentObject;
2888 // uniTargetParentName contains the directory the renamed object
2889 // will be moved to. Must obtain the TargetParentObject.
2892 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2893 AFS_TRACE_LEVEL_ERROR,
2894 "AFSSetRenameInfo Attempt to move %wZ to %wZ -- not yet supported (NOT_SAME_DEVICE)\n",
2895 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2896 &uniFullTargetName));
2898 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2902 pTargetDcb = pTargetParentObject->Fcb;
2908 // So here we have the target directory taken from the targetfile object
2911 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2913 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2915 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2918 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2919 // it is only the target component of the rename operation
2922 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2926 // The quick check to see if they are not really performing a rename
2927 // Do the names match? Only do this where the parent directories are
2931 if( pTargetParentObject == pSrcParentObject)
2934 if( FsRtlAreNamesEqual( &uniTargetName,
2939 try_return( ntStatus = STATUS_SUCCESS);
2942 bCommonParent = TRUE;
2947 bCommonParent = FALSE;
2951 // We do not allow cross-volume renames to occur
2954 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2957 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
2958 AFS_TRACE_LEVEL_ERROR,
2959 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2960 &pSrcCcb->DirectoryCB->NameInformation.FileName));
2962 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2965 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2968 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2971 bReleaseTargetDirLock = TRUE;
2973 if( pTargetParentObject != pSrcParentObject)
2975 AFSAcquireExcl( pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2978 bReleaseSourceDirLock = TRUE;
2980 pSourceDirLock = pSrcParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock;
2983 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2987 if( pTargetDirEntry == NULL)
2991 // Missed so perform a case insensitive lookup
2994 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2997 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
3002 if ( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3003 pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
3008 // Try the short name
3010 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
3016 // Increment our ref count on the dir entry
3019 if( pTargetDirEntry != NULL)
3022 ASSERT( BooleanFlagOn( pTargetDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
3023 AFSIsEqualFID( &pTargetParentObject->FileId, &pTargetDirEntry->ObjectInformation->ParentFileId));
3025 lCount = InterlockedIncrement( &pTargetDirEntry->DirOpenReferenceCount);
3027 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3028 AFS_TRACE_LEVEL_VERBOSE,
3029 "AFSSetRenameInfo Increment count on %wZ DE %p Ccb %p Cnt %d\n",
3030 &pTargetDirEntry->NameInformation.FileName,
3035 ASSERT( lCount >= 0);
3037 if( !bReplaceIfExists)
3040 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3041 AFS_TRACE_LEVEL_ERROR,
3042 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
3043 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3044 &pTargetDirEntry->NameInformation.FileName));
3046 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
3049 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3050 AFS_TRACE_LEVEL_ERROR,
3051 "AFSSetRenameInfo Target %wZ exists DE %p Count %d, performing delete of target\n",
3052 &pTargetDirEntry->NameInformation.FileName,
3057 // Pull the directory entry from the parent
3060 AFSRemoveDirNodeFromParent( pTargetParentObject,
3064 bTargetEntryExists = TRUE;
3068 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3069 AFS_TRACE_LEVEL_VERBOSE,
3070 "AFSSetRenameInfo Target does NOT exist, normal rename\n"));
3074 // We need to remove the DirEntry from the parent node, update the index
3075 // and reinsert it into the parent tree. Note that for entries with the
3076 // same parent we do not pull the node from the enumeration list
3079 AFSRemoveDirNodeFromParent( pSrcParentObject,
3080 pSrcCcb->DirectoryCB,
3084 // OK, this is a simple rename. Issue the rename
3085 // request to the service.
3088 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
3089 &pSrcCcb->AuthGroup,
3091 pTargetDcb->ObjectInformation,
3092 pSrcCcb->DirectoryCB,
3096 if( !NT_SUCCESS( ntStatus))
3100 // Attempt to re-insert the directory entry
3103 AFSInsertDirectoryNode( pSrcParentObject,
3104 pSrcCcb->DirectoryCB,
3107 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3108 AFS_TRACE_LEVEL_ERROR,
3109 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
3110 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3114 try_return( ntStatus);
3118 // Set the notification up for the source file
3121 if( pSrcParentObject == pTargetParentObject &&
3122 !bTargetEntryExists)
3125 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
3130 ulNotificationAction = FILE_ACTION_REMOVED;
3133 if( pSrcFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
3136 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
3141 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
3144 AFSFsRtlNotifyFullReportChange( pSrcParentObject,
3146 (ULONG)ulNotifyFilter,
3147 (ULONG)ulNotificationAction);
3150 // Update the name in the dir entry.
3153 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
3156 if( !NT_SUCCESS( ntStatus))
3160 // Attempt to re-insert the directory entry
3163 AFSInsertDirectoryNode( pSrcParentObject,
3164 pSrcCcb->DirectoryCB,
3167 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3168 AFS_TRACE_LEVEL_ERROR,
3169 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
3170 &pSrcCcb->DirectoryCB->NameInformation.FileName,
3174 try_return( ntStatus);
3178 // Update the object information block, if needed
3181 if( !AFSIsEqualFID( &pSrcObject->FileId,
3185 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
3189 // Remove the old information entry
3192 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3193 &pSrcObject->TreeEntry);
3195 RtlCopyMemory( &pSrcObject->FileId,
3197 sizeof( AFSFileID));
3200 // Insert the entry into the new object table.
3203 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
3205 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
3208 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
3213 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
3214 &pSrcObject->TreeEntry)))
3218 // Lost a race, an ObjectInfo object already exists for this FID.
3219 // Let this copy be garbage collected.
3222 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
3226 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
3230 // Update the hash values for the name trees.
3233 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3236 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3239 if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
3240 pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
3241 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
3246 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
3247 uniShortName.MaximumLength = uniShortName.Length;
3248 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
3250 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
3253 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3254 AFS_TRACE_LEVEL_VERBOSE,
3255 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
3257 &pSrcCcb->DirectoryCB->NameInformation.FileName));
3262 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
3269 // Update the file index for the object in the new parent
3272 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
3276 // Re-insert the directory entry
3279 AFSInsertDirectoryNode( pTargetParentObject,
3280 pSrcCcb->DirectoryCB,
3284 // Update the parent pointer in the source object if they are different
3287 if( pSrcParentObject != pTargetParentObject)
3290 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenHandleCount);
3292 lCount = InterlockedDecrement( &pSrcParentObject->Specific.Directory.ChildOpenReferenceCount);
3294 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
3296 lCount = InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
3300 // Guaranteed to be in the same volume
3303 AFSAcquireExcl( pSrcParentObject->VolumeCB->ObjectInfoTree.TreeLock,
3306 lCount = AFSObjectInfoIncrement( pTargetParentObject,
3307 AFS_OBJECT_REFERENCE_CHILD);
3309 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3310 AFS_TRACE_LEVEL_VERBOSE,
3311 "AFSSetRenameInfo Increment count on parent object %p Cnt %d\n",
3312 pTargetParentObject,
3315 lCount = AFSObjectInfoDecrement( pSrcParentObject,
3316 AFS_OBJECT_REFERENCE_CHILD);
3318 AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
3319 AFS_TRACE_LEVEL_VERBOSE,
3320 "AFSSetRenameInfo Decrement count on parent object %p Cnt %d\n",
3324 pSrcFcb->ObjectInformation->ParentFileId = pTargetParentObject->FileId;
3326 SetFlag( pSrcFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID);
3328 AFSReleaseResource( pSrcParentObject->VolumeCB->ObjectInfoTree.TreeLock);
3330 ulNotificationAction = FILE_ACTION_ADDED;
3335 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
3339 // Now update the notification for the target file
3342 AFSFsRtlNotifyFullReportChange( pTargetParentObject,
3344 (ULONG)ulNotifyFilter,
3345 (ULONG)ulNotificationAction);
3348 // If we performed the rename of the target because it existed, we now need to
3349 // delete the tmp target we created above
3352 if( bTargetEntryExists)
3355 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3356 AFS_TRACE_LEVEL_VERBOSE,
3357 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
3359 &pTargetDirEntry->NameInformation.FileName));
3361 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
3364 // Try and purge the cache map if this is a file
3367 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
3368 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
3369 pTargetDirEntry->DirOpenReferenceCount > 1)
3372 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
3375 ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
3377 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount); // The count we added above
3379 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3380 AFS_TRACE_LEVEL_VERBOSE,
3381 "AFSSetRenameInfo Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
3382 &pTargetDirEntry->NameInformation.FileName,
3387 ASSERT( lCount >= 0);
3390 pTargetDirEntry->NameArrayReferenceCount <= 0)
3393 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3394 AFS_TRACE_LEVEL_VERBOSE,
3395 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
3397 &pTargetDirEntry->NameInformation.FileName));
3399 AFSDeleteDirEntry( pTargetParentObject,
3403 pTargetDirEntry = NULL;
3405 if ( pTargetFcb != NULL)
3409 // Do not hold TreeLocks across the MmForceSectionClosed() call as
3410 // it can deadlock with Trend Micro's TmPreFlt!TmpQueryFullName
3413 if( bReleaseTargetDirLock)
3415 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3417 bReleaseTargetDirLock = FALSE;
3420 if( bReleaseSourceDirLock)
3423 AFSReleaseResource( pSourceDirLock);
3425 bReleaseSourceDirLock = FALSE;
3429 // MmForceSectionClosed() can eventually call back into AFSCleanup
3430 // which will need to acquire Fcb->Resource exclusively. Failure
3431 // to obtain it here before holding the SectionObjectResource will
3432 // permit the locks to be obtained out of order risking a deadlock.
3435 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3436 AFS_TRACE_LEVEL_VERBOSE,
3437 "AFSSetRenameInfo Acquiring Fcb lock %p EXCL %08lX\n",
3438 &pTargetFcb->NPFcb->Resource,
3439 PsGetCurrentThread()));
3441 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
3444 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3445 AFS_TRACE_LEVEL_VERBOSE,
3446 "AFSSetRenameInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3447 &pTargetFcb->NPFcb->SectionObjectResource,
3448 PsGetCurrentThread()));
3450 AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
3454 // Close the section in the event it was mapped
3457 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
3461 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
3462 AFS_TRACE_LEVEL_ERROR,
3463 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
3467 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3468 AFS_TRACE_LEVEL_VERBOSE,
3469 "AFSSetRenameInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3470 &pTargetFcb->NPFcb->SectionObjectResource,
3471 PsGetCurrentThread()));
3473 AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
3475 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3476 AFS_TRACE_LEVEL_VERBOSE,
3477 "AFSSetRenameInfo Releasing Fcb lock %p EXCL %08lX\n",
3478 &pTargetFcb->NPFcb->Resource,
3479 PsGetCurrentThread()));
3481 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
3487 if( !NT_SUCCESS( ntStatus))
3490 if( bTargetEntryExists)
3493 ASSERT( pTargetParentObject != NULL);
3495 AFSInsertDirectoryNode( pTargetParentObject,
3501 if( pTargetDirEntry != NULL)
3504 lCount = InterlockedDecrement( &pTargetDirEntry->DirOpenReferenceCount);
3506 AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
3507 AFS_TRACE_LEVEL_VERBOSE,
3508 "AFSSetRenameInfo Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
3509 &pTargetDirEntry->NameInformation.FileName,
3514 ASSERT( lCount >= 0);
3517 if( bReleaseTargetDirLock)
3520 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
3523 if( bReleaseSourceDirLock)
3526 AFSReleaseResource( pSourceDirLock);
3529 if ( bDereferenceTargetParentObject)
3532 ObDereferenceObject( pTargetParentFileObj);
3535 if ( pSrcParentObject != NULL)
3538 AFSReleaseObjectInfo( &pSrcParentObject);
3542 // No need to release pTargetParentObject as it is either a copy of pSrcParentObject
3543 // or (AFSFcb *)pTargetFileObj->FsContext->ObjectInformation
3546 pTargetParentObject = NULL;
3553 AFSSetPositionInfo( IN PIRP Irp,
3554 IN AFSDirectoryCB *DirectoryCB)
3556 UNREFERENCED_PARAMETER(DirectoryCB);
3557 NTSTATUS ntStatus = STATUS_SUCCESS;
3558 PFILE_POSITION_INFORMATION pBuffer;
3559 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3561 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3563 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
3569 AFSSetAllocationInfo( IN PIRP Irp,
3570 IN AFSDirectoryCB *DirectoryCB)
3572 UNREFERENCED_PARAMETER(DirectoryCB);
3573 NTSTATUS ntStatus = STATUS_SUCCESS;
3574 PFILE_ALLOCATION_INFORMATION pBuffer;
3575 BOOLEAN bReleasePaging = FALSE;
3576 BOOLEAN bTellCc = FALSE;
3577 BOOLEAN bTellService = FALSE;
3578 BOOLEAN bUserMapped = FALSE;
3579 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3580 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3581 AFSFcb *pFcb = NULL;
3582 AFSCcb *pCcb = NULL;
3583 LARGE_INTEGER liSaveAlloc;
3584 LARGE_INTEGER liSaveFileSize;
3585 LARGE_INTEGER liSaveVDL;
3587 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3589 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3591 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3594 // save values to put back
3596 liSaveAlloc = pFcb->Header.AllocationSize;
3597 liSaveFileSize = pFcb->Header.FileSize;
3598 liSaveVDL = pFcb->Header.ValidDataLength;
3600 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
3601 pIrpSp->Parameters.SetFile.AdvanceOnly)
3603 return STATUS_SUCCESS ;
3606 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3609 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3610 AFS_TRACE_LEVEL_VERBOSE,
3611 "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3612 &pFcb->NPFcb->SectionObjectResource,
3613 PsGetCurrentThread()));
3615 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3618 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3619 &pBuffer->AllocationSize);
3621 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3622 AFS_TRACE_LEVEL_VERBOSE,
3623 "AFSSetAllocationInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3624 &pFcb->NPFcb->SectionObjectResource,
3625 PsGetCurrentThread()));
3627 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3630 // Truncating the file
3635 ntStatus = STATUS_USER_MAPPED_FILE ;
3641 // If this is a truncation we need to grab the paging IO resource.
3644 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3645 AFS_TRACE_LEVEL_VERBOSE,
3646 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3647 &pFcb->NPFcb->PagingResource,
3648 PsGetCurrentThread()));
3650 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3653 bReleasePaging = TRUE;
3656 // Must drop the Fcb Resource. When changing the file size
3657 // a deadlock can occur with Trend Micro's filter if the file
3658 // size is set to zero.
3661 AFSReleaseResource( &pFcb->NPFcb->Resource);
3663 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3665 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3668 // Tell Cc that Allocation is moved.
3672 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
3675 // We are pulling the EOF back as well so we need to tell
3678 bTellService = TRUE;
3680 pFcb->Header.FileSize = pBuffer->AllocationSize;
3682 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
3690 // Tell Cc if allocation is increased.
3693 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3694 AFS_TRACE_LEVEL_VERBOSE,
3695 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3696 &pFcb->NPFcb->PagingResource,
3697 PsGetCurrentThread()));
3699 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3702 bReleasePaging = TRUE;
3705 // Must drop the Fcb Resource. When changing the file size
3706 // a deadlock can occur with Trend Micro's filter if the file
3707 // size is set to zero.
3710 AFSReleaseResource( &pFcb->NPFcb->Resource);
3712 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
3714 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
3716 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
3720 // Now Tell the server if we have to
3725 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3727 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3728 pFcb->ObjectInformation,
3732 if (NT_SUCCESS(ntStatus))
3735 // Trim extents if we told the service - the update has done an implicit
3736 // trim at the service.
3740 AFSTrimExtents( pFcb,
3741 &pFcb->Header.FileSize);
3744 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3746 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3749 CcIsFileCached( pFileObject))
3751 CcSetFileSizes( pFileObject,
3752 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3758 // Put the saved values back
3760 pFcb->Header.ValidDataLength = liSaveVDL;
3761 pFcb->Header.FileSize = liSaveFileSize;
3762 pFcb->Header.AllocationSize = liSaveAlloc;
3763 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
3764 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3770 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3772 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3780 AFSSetEndOfFileInfo( IN PIRP Irp,
3781 IN AFSDirectoryCB *DirectoryCB)
3783 UNREFERENCED_PARAMETER(DirectoryCB);
3784 NTSTATUS ntStatus = STATUS_SUCCESS;
3785 PFILE_END_OF_FILE_INFORMATION pBuffer;
3786 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3787 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
3788 LARGE_INTEGER liSaveSize;
3789 LARGE_INTEGER liSaveVDL;
3790 LARGE_INTEGER liSaveAlloc;
3791 BOOLEAN bModified = FALSE;
3792 BOOLEAN bReleasePaging = FALSE;
3793 BOOLEAN bTruncated = FALSE;
3794 BOOLEAN bUserMapped = FALSE;
3795 AFSFcb *pFcb = NULL;
3796 AFSCcb *pCcb = NULL;
3798 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3800 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3802 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3804 liSaveSize = pFcb->Header.FileSize;
3805 liSaveAlloc = pFcb->Header.AllocationSize;
3806 liSaveVDL = pFcb->Header.ValidDataLength;
3808 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
3809 !pIrpSp->Parameters.SetFile.AdvanceOnly)
3812 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
3815 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3816 AFS_TRACE_LEVEL_VERBOSE,
3817 "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
3818 &pFcb->NPFcb->SectionObjectResource,
3819 PsGetCurrentThread()));
3821 AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
3824 bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
3825 &pBuffer->EndOfFile);
3827 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3828 AFS_TRACE_LEVEL_VERBOSE,
3829 "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %p EXCL %08lX\n",
3830 &pFcb->NPFcb->SectionObjectResource,
3831 PsGetCurrentThread()));
3833 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
3835 // Truncating the file
3839 ntStatus = STATUS_USER_MAPPED_FILE;
3845 // If this is a truncation we need to grab the paging
3848 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3849 AFS_TRACE_LEVEL_VERBOSE,
3850 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3851 &pFcb->NPFcb->PagingResource,
3852 PsGetCurrentThread()));
3854 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3857 bReleasePaging = TRUE;
3860 // Must drop the Fcb Resource. When changing the file size
3861 // a deadlock can occur with Trend Micro's filter if the file
3862 // size is set to zero.
3865 AFSReleaseResource( &pFcb->NPFcb->Resource);
3867 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3869 pFcb->Header.FileSize = pBuffer->EndOfFile;
3871 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3873 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3875 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
3878 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
3890 // extending the file, move EOF
3894 // If this is a truncation we need to grab the paging
3897 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
3898 AFS_TRACE_LEVEL_VERBOSE,
3899 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %p EXCL %08lX\n",
3900 &pFcb->NPFcb->PagingResource,
3901 PsGetCurrentThread()));
3903 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
3906 bReleasePaging = TRUE;
3909 // Must drop the Fcb Resource. When changing the file size
3910 // a deadlock can occur with Trend Micro's filter if the file
3911 // size is set to zero.
3914 AFSReleaseResource( &pFcb->NPFcb->Resource);
3916 pFcb->Header.FileSize = pBuffer->EndOfFile;
3918 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
3920 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
3923 // And Allocation as needed.
3925 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
3927 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
3937 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
3939 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
3945 ASSERT( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID));
3947 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentFileId,
3948 pFcb->ObjectInformation,
3951 if( NT_SUCCESS(ntStatus))
3954 // We are now good to go so tell CC.
3956 CcSetFileSizes( pFileObject,
3957 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
3960 // And give up those extents
3965 AFSTrimExtents( pFcb,
3966 &pFcb->Header.FileSize);
3971 pFcb->Header.ValidDataLength = liSaveVDL;
3972 pFcb->Header.FileSize = liSaveSize;
3973 pFcb->Header.AllocationSize = liSaveAlloc;
3974 pFcb->ObjectInformation->EndOfFile = liSaveSize;
3975 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
3982 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
3984 AFSAcquireExcl( &pFcb->NPFcb->Resource,
3992 AFSProcessShareSetInfo( IN IRP *Irp,
3997 UNREFERENCED_PARAMETER(Fcb);
3998 NTSTATUS ntStatus = STATUS_SUCCESS;
3999 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4000 FILE_INFORMATION_CLASS ulFileInformationClass;
4001 void *pPipeInfo = NULL;
4005 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
4007 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4008 AFS_TRACE_LEVEL_VERBOSE,
4009 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
4010 &Ccb->DirectoryCB->NameInformation.FileName,
4011 ulFileInformationClass));
4013 pPipeInfo = AFSLockSystemBuffer( Irp,
4014 pIrpSp->Parameters.SetFile.Length);
4016 if( pPipeInfo == NULL)
4019 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4020 AFS_TRACE_LEVEL_ERROR,
4021 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
4022 &Ccb->DirectoryCB->NameInformation.FileName));
4024 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4028 // Send the request to the service
4031 ntStatus = AFSNotifySetPipeInfo( Ccb,
4032 (ULONG)ulFileInformationClass,
4033 pIrpSp->Parameters.SetFile.Length,
4036 if( !NT_SUCCESS( ntStatus))
4039 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4040 AFS_TRACE_LEVEL_ERROR,
4041 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
4042 &Ccb->DirectoryCB->NameInformation.FileName,
4045 try_return( ntStatus);
4048 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4049 AFS_TRACE_LEVEL_VERBOSE,
4050 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
4051 &Ccb->DirectoryCB->NameInformation.FileName,
4052 ulFileInformationClass));
4063 AFSProcessShareQueryInfo( IN IRP *Irp,
4068 UNREFERENCED_PARAMETER(Fcb);
4069 NTSTATUS ntStatus = STATUS_SUCCESS;
4070 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4071 FILE_INFORMATION_CLASS ulFileInformationClass;
4072 void *pPipeInfo = NULL;
4077 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
4079 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4080 AFS_TRACE_LEVEL_VERBOSE,
4081 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
4082 &Ccb->DirectoryCB->NameInformation.FileName,
4083 ulFileInformationClass));
4085 pPipeInfo = AFSLockSystemBuffer( Irp,
4086 pIrpSp->Parameters.QueryFile.Length);
4088 if( pPipeInfo == NULL)
4091 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4092 AFS_TRACE_LEVEL_ERROR,
4093 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
4094 &Ccb->DirectoryCB->NameInformation.FileName));
4096 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
4100 // Send the request to the service
4103 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
4104 (ULONG)ulFileInformationClass,
4105 pIrpSp->Parameters.QueryFile.Length,
4107 (ULONG *)&Irp->IoStatus.Information);
4109 if( !NT_SUCCESS( ntStatus))
4112 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4113 AFS_TRACE_LEVEL_ERROR,
4114 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
4115 &Ccb->DirectoryCB->NameInformation.FileName,
4118 try_return( ntStatus);
4121 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
4122 AFS_TRACE_LEVEL_VERBOSE,
4123 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
4124 &Ccb->DirectoryCB->NameInformation.FileName,
4125 ulFileInformationClass));
4136 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
4139 IN OUT LONG *Length)
4142 UNREFERENCED_PARAMETER(Fcb);
4143 UNREFERENCED_PARAMETER(Ccb);
4144 NTSTATUS ntStatus = STATUS_SUCCESS;
4145 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
4146 FILE_INFORMATION_CLASS ulFileInformationClass;
4151 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
4153 switch( ulFileInformationClass)
4156 case FileBasicInformation:
4159 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4160 AFS_TRACE_LEVEL_VERBOSE,
4161 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n"));
4163 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
4165 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4167 pBasic->CreationTime.QuadPart = 0;
4168 pBasic->LastAccessTime.QuadPart = 0;
4169 pBasic->ChangeTime.QuadPart = 0;
4170 pBasic->LastWriteTime.QuadPart = 0;
4171 pBasic->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
4173 *Length -= sizeof( FILE_BASIC_INFORMATION);
4177 ntStatus = STATUS_BUFFER_TOO_SMALL;
4183 case FileStandardInformation:
4186 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4187 AFS_TRACE_LEVEL_VERBOSE,
4188 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n"));
4190 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
4192 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4194 pStandard->NumberOfLinks = 1;
4195 pStandard->DeletePending = 0;
4196 pStandard->AllocationSize.QuadPart = 0;
4197 pStandard->EndOfFile.QuadPart = 0;
4198 pStandard->Directory = 0;
4200 *Length -= sizeof( FILE_STANDARD_INFORMATION);
4204 ntStatus = STATUS_BUFFER_TOO_SMALL;
4210 case FileNormalizedNameInformation:
4211 case FileNameInformation:
4214 ULONG ulCopyLength = 0;
4215 AFSFcb *pFcb = NULL;
4216 AFSCcb *pCcb = NULL;
4217 USHORT usFullNameLength = 0;
4218 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4219 UNICODE_STRING uniName;
4221 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4222 AFS_TRACE_LEVEL_VERBOSE,
4223 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n"));
4225 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
4226 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
4228 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
4230 ntStatus = STATUS_BUFFER_TOO_SMALL;
4234 RtlZeroMemory( pNameInfo,
4237 usFullNameLength = sizeof( WCHAR) +
4238 AFSServerName.Length +
4239 pCcb->FullFileName.Length;
4241 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
4243 ulCopyLength = (LONG)usFullNameLength;
4247 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4248 ntStatus = STATUS_BUFFER_OVERFLOW;
4251 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
4253 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
4255 if( ulCopyLength > 0)
4258 pNameInfo->FileName[ 0] = L'\\';
4259 ulCopyLength -= sizeof( WCHAR);
4261 *Length -= sizeof( WCHAR);
4263 if( ulCopyLength >= AFSServerName.Length)
4266 RtlCopyMemory( &pNameInfo->FileName[ 1],
4267 AFSServerName.Buffer,
4268 AFSServerName.Length);
4270 ulCopyLength -= AFSServerName.Length;
4271 *Length -= AFSServerName.Length;
4273 if( ulCopyLength >= pCcb->FullFileName.Length)
4276 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4277 pCcb->FullFileName.Buffer,
4278 pCcb->FullFileName.Length);
4280 ulCopyLength -= pCcb->FullFileName.Length;
4281 *Length -= pCcb->FullFileName.Length;
4283 uniName.Length = (USHORT)pNameInfo->FileNameLength;
4284 uniName.MaximumLength = uniName.Length;
4285 uniName.Buffer = pNameInfo->FileName;
4290 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
4291 pCcb->FullFileName.Buffer,
4294 *Length -= ulCopyLength;
4296 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
4297 uniName.MaximumLength = uniName.Length;
4298 uniName.Buffer = pNameInfo->FileName;
4301 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4302 AFS_TRACE_LEVEL_VERBOSE,
4303 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
4311 case FileInternalInformation:
4314 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
4316 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4317 AFS_TRACE_LEVEL_VERBOSE,
4318 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n"));
4320 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
4323 pInternalInfo->IndexNumber.HighPart = 0;
4325 pInternalInfo->IndexNumber.LowPart = 0;
4327 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
4332 ntStatus = STATUS_BUFFER_TOO_SMALL;
4338 case FileAllInformation:
4340 ntStatus = STATUS_INVALID_PARAMETER;
4342 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4343 AFS_TRACE_LEVEL_WARNING,
4344 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n"));
4349 case FileEaInformation:
4351 ntStatus = STATUS_INVALID_PARAMETER;
4353 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4354 AFS_TRACE_LEVEL_WARNING,
4355 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n"));
4360 case FilePositionInformation:
4362 ntStatus = STATUS_INVALID_PARAMETER;
4364 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4365 AFS_TRACE_LEVEL_WARNING,
4366 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n"));
4371 case FileAlternateNameInformation:
4373 ntStatus = STATUS_INVALID_PARAMETER;
4375 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4376 AFS_TRACE_LEVEL_WARNING,
4377 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n"));
4382 case FileNetworkOpenInformation:
4384 ntStatus = STATUS_INVALID_PARAMETER;
4386 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4387 AFS_TRACE_LEVEL_WARNING,
4388 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n"));
4393 case FileStreamInformation:
4395 ntStatus = STATUS_INVALID_PARAMETER;
4397 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4398 AFS_TRACE_LEVEL_WARNING,
4399 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n"));
4404 case FileAttributeTagInformation:
4406 ntStatus = STATUS_INVALID_PARAMETER;
4408 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4409 AFS_TRACE_LEVEL_WARNING,
4410 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n"));
4415 case FileRemoteProtocolInformation:
4417 ntStatus = STATUS_INVALID_PARAMETER;
4419 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4420 AFS_TRACE_LEVEL_WARNING,
4421 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n"));
4426 case FileNetworkPhysicalNameInformation:
4428 ntStatus = STATUS_INVALID_PARAMETER;
4430 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4431 AFS_TRACE_LEVEL_WARNING,
4432 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n"));
4439 ntStatus = STATUS_INVALID_PARAMETER;
4441 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4442 AFS_TRACE_LEVEL_WARNING,
4443 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
4444 ulFileInformationClass));
4451 AFSDbgTrace(( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
4452 AFS_TRACE_LEVEL_VERBOSE,
4453 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",