2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * - Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
14 * this list of conditions and the following disclaimer in the
16 * and/or other materials provided with the distribution.
17 * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
18 * nor the names of their contributors may be used to endorse or promote
19 * products derived from this software without specific prior written
20 * permission from Kernel Drivers, LLC and Your File System, Inc.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 // File: AFSFileInfo.cpp
39 #include "AFSCommon.h"
42 // Function: AFSQueryFileInfo
46 // This function is the dispatch handler for the IRP_MJ_QUERY_FILE_INFORMATION request
50 // A status is returned for the function
54 AFSQueryFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
58 NTSTATUS ntStatus = STATUS_SUCCESS;
59 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
60 ULONG ulRequestType = 0;
61 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
64 PFILE_OBJECT pFileObject;
65 BOOLEAN bReleaseMain = FALSE;
67 FILE_INFORMATION_CLASS stFileInformationClass;
74 // Determine the type of request this request is
77 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
79 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
84 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
85 AFS_TRACE_LEVEL_ERROR,
86 "AFSQueryFileInfo Attempted access (%08lX) when pFcb == NULL\n",
89 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
92 lLength = (LONG)pIrpSp->Parameters.QueryFile.Length;
93 stFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
94 pBuffer = Irp->AssociatedIrp.SystemBuffer;
97 // Grab the main shared right off the bat
100 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
101 AFS_TRACE_LEVEL_VERBOSE,
102 "AFSQueryFileInfo Acquiring Fcb lock %08lX SHARED %08lX\n",
103 &pFcb->NPFcb->Resource,
104 PsGetCurrentThread());
106 AFSAcquireShared( &pFcb->NPFcb->Resource,
112 // Don't allow requests against IOCtl nodes
115 if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
118 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
119 AFS_TRACE_LEVEL_VERBOSE,
120 "AFSQueryFileInfo Processing request against SpecialShare Fcb\n");
122 ntStatus = AFSProcessShareQueryInfo( Irp,
126 try_return( ntStatus);
128 else if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
130 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
131 AFS_TRACE_LEVEL_VERBOSE,
132 "AFSQueryFileInfo request against PIOCtl Fcb\n");
134 ntStatus = AFSProcessPIOCtlQueryInfo( Irp,
139 try_return( ntStatus);
143 // Process the request
146 switch( stFileInformationClass)
149 case FileAllInformation:
152 PFILE_ALL_INFORMATION pAllInfo;
155 // For the all information class we'll typecast a local
156 // pointer to the output buffer and then call the
157 // individual routines to fill in the buffer.
160 pAllInfo = (PFILE_ALL_INFORMATION)pBuffer;
162 ntStatus = AFSQueryBasicInfo( Irp,
164 &pAllInfo->BasicInformation,
167 if( !NT_SUCCESS( ntStatus))
170 try_return( ntStatus);
173 ntStatus = AFSQueryStandardInfo( Irp,
175 &pAllInfo->StandardInformation,
178 if( !NT_SUCCESS( ntStatus))
181 try_return( ntStatus);
184 ntStatus = AFSQueryInternalInfo( Irp,
186 &pAllInfo->InternalInformation,
189 if( !NT_SUCCESS( ntStatus))
192 try_return( ntStatus);
195 ntStatus = AFSQueryEaInfo( Irp,
197 &pAllInfo->EaInformation,
200 if( !NT_SUCCESS( ntStatus))
203 try_return( ntStatus);
206 ntStatus = AFSQueryAccess( Irp,
208 &pAllInfo->AccessInformation,
211 if( !NT_SUCCESS( ntStatus))
214 try_return( ntStatus);
217 ntStatus = AFSQueryPositionInfo( Irp,
219 &pAllInfo->PositionInformation,
222 if( !NT_SUCCESS( ntStatus))
225 try_return( ntStatus);
228 ntStatus = AFSQueryMode( Irp,
230 &pAllInfo->ModeInformation,
233 if( !NT_SUCCESS( ntStatus))
236 try_return( ntStatus);
239 ntStatus = AFSQueryAlignment( Irp,
241 &pAllInfo->AlignmentInformation,
244 if( !NT_SUCCESS( ntStatus))
247 try_return( ntStatus);
250 ntStatus = AFSQueryNameInfo( Irp,
252 &pAllInfo->NameInformation,
255 if( !NT_SUCCESS( ntStatus))
258 try_return( ntStatus);
264 case FileBasicInformation:
267 ntStatus = AFSQueryBasicInfo( Irp,
269 (PFILE_BASIC_INFORMATION)pBuffer,
275 case FileStandardInformation:
278 ntStatus = AFSQueryStandardInfo( Irp,
280 (PFILE_STANDARD_INFORMATION)pBuffer,
286 case FileInternalInformation:
289 ntStatus = AFSQueryInternalInfo( Irp,
291 (PFILE_INTERNAL_INFORMATION)pBuffer,
297 case FileEaInformation:
300 ntStatus = AFSQueryEaInfo( Irp,
302 (PFILE_EA_INFORMATION)pBuffer,
308 case FilePositionInformation:
311 ntStatus = AFSQueryPositionInfo( Irp,
313 (PFILE_POSITION_INFORMATION)pBuffer,
319 case FileNameInformation:
322 ntStatus = AFSQueryNameInfo( Irp,
324 (PFILE_NAME_INFORMATION)pBuffer,
330 case FileAlternateNameInformation:
333 ntStatus = AFSQueryShortNameInfo( Irp,
335 (PFILE_NAME_INFORMATION)pBuffer,
341 case FileNetworkOpenInformation:
344 ntStatus = AFSQueryNetworkInfo( Irp,
346 (PFILE_NETWORK_OPEN_INFORMATION)pBuffer,
352 case FileStreamInformation:
355 ntStatus = AFSQueryStreamInfo( Irp,
357 (FILE_STREAM_INFORMATION *)pBuffer,
364 case FileAttributeTagInformation:
367 ntStatus = AFSQueryAttribTagInfo( Irp,
369 (FILE_ATTRIBUTE_TAG_INFORMATION *)pBuffer,
375 case FileRemoteProtocolInformation:
378 ntStatus = AFSQueryRemoteProtocolInfo( Irp,
380 (FILE_REMOTE_PROTOCOL_INFORMATION *)pBuffer,
386 case FileNetworkPhysicalNameInformation:
389 ntStatus = AFSQueryPhysicalNameInfo( Irp,
391 (FILE_NETWORK_PHYSICAL_NAME_INFORMATION *)pBuffer,
399 ntStatus = STATUS_INVALID_PARAMETER;
406 Irp->IoStatus.Information = pIrpSp->Parameters.QueryFile.Length - lLength;
411 AFSReleaseResource( &pFcb->NPFcb->Resource);
414 if( !NT_SUCCESS( ntStatus) &&
415 ntStatus != STATUS_INVALID_PARAMETER &&
416 ntStatus != STATUS_BUFFER_OVERFLOW)
420 pCcb->DirectoryCB != NULL)
423 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
424 AFS_TRACE_LEVEL_ERROR,
425 "AFSQueryFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
426 &pCcb->DirectoryCB->NameInformation.FileName,
427 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
428 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
429 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
430 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
435 __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
440 "EXCEPTION - AFSQueryFileInfo\n");
442 ntStatus = STATUS_UNSUCCESSFUL;
447 AFSReleaseResource( &pFcb->NPFcb->Resource);
451 AFSCompleteRequest( Irp,
458 // Function: AFSSetFileInfo
462 // This function is the dispatch handler for the IRP_MJ_SET_FILE_INFORMATION request
466 // A status is returned for the function
470 AFSSetFileInfo( IN PDEVICE_OBJECT LibDeviceObject,
474 NTSTATUS ntStatus = STATUS_SUCCESS;
475 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
476 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
479 BOOLEAN bCompleteRequest = TRUE;
480 FILE_INFORMATION_CLASS FileInformationClass;
481 BOOLEAN bCanQueueRequest = FALSE;
482 PFILE_OBJECT pFileObject = NULL;
483 BOOLEAN bReleaseMain = FALSE;
484 BOOLEAN bUpdateFileInfo = FALSE;
485 AFSFileID stParentFileId;
490 pFileObject = pIrpSp->FileObject;
492 pFcb = (AFSFcb *)pFileObject->FsContext;
493 pCcb = (AFSCcb *)pFileObject->FsContext2;
498 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
499 AFS_TRACE_LEVEL_ERROR,
500 "AFSSetFileInfo Attempted access (%08lX) when pFcb == NULL\n",
503 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
506 bCanQueueRequest = !(IoIsOperationSynchronous( Irp) | (KeGetCurrentIrql() != PASSIVE_LEVEL));
507 FileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
513 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
514 AFS_TRACE_LEVEL_VERBOSE,
515 "AFSSetFileInfo Acquiring Fcb lock %08lX EXCL %08lX\n",
516 &pFcb->NPFcb->Resource,
517 PsGetCurrentThread());
519 AFSAcquireExcl( &pFcb->NPFcb->Resource,
525 // Don't allow requests against IOCtl nodes
528 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
531 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
532 AFS_TRACE_LEVEL_ERROR,
533 "AFSSetFileInfo Failing request against PIOCtl Fcb\n");
535 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
537 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
540 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
541 AFS_TRACE_LEVEL_VERBOSE,
542 "AFSSetFileInfo Processing request against SpecialShare Fcb\n");
544 ntStatus = AFSProcessShareSetInfo( Irp,
548 try_return( ntStatus);
551 if( BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
554 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
555 AFS_TRACE_LEVEL_ERROR,
556 "AFSSetFileInfo Request failed due to read only volume\n",
559 try_return( ntStatus = STATUS_ACCESS_DENIED);
563 // Ensure rename operations are synchronous
566 if( FileInformationClass == FileRenameInformation)
569 bCanQueueRequest = FALSE;
573 // Store away the parent fid
576 RtlZeroMemory( &stParentFileId,
579 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
581 stParentFileId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
585 // Process the request
588 switch( FileInformationClass)
591 case FileBasicInformation:
594 bUpdateFileInfo = TRUE;
596 ntStatus = AFSSetBasicInfo( Irp,
602 case FileDispositionInformation:
605 ntStatus = AFSSetDispositionInfo( Irp,
611 case FileRenameInformation:
614 ntStatus = AFSSetRenameInfo( Irp);
619 case FilePositionInformation:
622 ntStatus = AFSSetPositionInfo( Irp,
628 case FileLinkInformation:
631 ntStatus = STATUS_INVALID_DEVICE_REQUEST;
636 case FileAllocationInformation:
639 ntStatus = AFSSetAllocationInfo( Irp,
645 case FileEndOfFileInformation:
648 ntStatus = AFSSetEndOfFileInfo( Irp,
656 ntStatus = STATUS_INVALID_PARAMETER;
666 AFSReleaseResource( &pFcb->NPFcb->Resource);
669 if( NT_SUCCESS( ntStatus) &&
673 ntStatus = AFSUpdateFileInformation( &stParentFileId,
674 pFcb->ObjectInformation,
677 if( !NT_SUCCESS( ntStatus))
680 AFSAcquireExcl( &pFcb->NPFcb->Resource,
684 // Unwind the update and fail the request
687 AFSUnwindFileInfo( pFcb,
690 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
691 AFS_TRACE_LEVEL_ERROR,
692 "AFSSetFileInfo Failed to send file info update to service request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
693 &pCcb->DirectoryCB->NameInformation.FileName,
694 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
695 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
696 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
697 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
700 AFSReleaseResource( &pFcb->NPFcb->Resource);
704 if( !NT_SUCCESS( ntStatus))
708 pCcb->DirectoryCB != NULL)
711 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
712 AFS_TRACE_LEVEL_ERROR,
713 "AFSSetFileInfo Failed to process request for %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
714 &pCcb->DirectoryCB->NameInformation.FileName,
715 pCcb->DirectoryCB->ObjectInformation->FileId.Cell,
716 pCcb->DirectoryCB->ObjectInformation->FileId.Volume,
717 pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
718 pCcb->DirectoryCB->ObjectInformation->FileId.Unique,
723 __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
728 "EXCEPTION - AFSSetFileInfo\n");
730 ntStatus = STATUS_UNSUCCESSFUL;
733 AFSCompleteRequest( Irp,
740 // Function: AFSQueryBasicInfo
744 // This function is the handler for the query basic information request
748 // A status is returned for the function
752 AFSQueryBasicInfo( IN PIRP Irp,
753 IN AFSDirectoryCB *DirectoryCB,
754 IN OUT PFILE_BASIC_INFORMATION Buffer,
757 NTSTATUS ntStatus = STATUS_SUCCESS;
758 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
759 ULONG ulFileAttribs = 0;
762 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
763 AFSFileInfoCB stFileInfo;
764 AFSDirectoryCB *pParentDirectoryCB = NULL;
765 UNICODE_STRING uniParentPath;
767 if( *Length >= sizeof( FILE_BASIC_INFORMATION))
770 RtlZeroMemory( Buffer,
773 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
775 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
776 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
778 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
781 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
783 AFSRetrieveParentPath( &pCcb->FullFileName,
786 RtlZeroMemory( &stFileInfo,
787 sizeof( AFSFileInfoCB));
790 // Can't hold the Fcb while evaluating the path, leads to lock inversion
793 AFSReleaseResource( &pFcb->NPFcb->Resource);
795 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
802 ulFileAttribs = stFileInfo.FileAttributes;
804 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
807 AFSAcquireShared( &pFcb->NPFcb->Resource,
812 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
813 AFS_TRACE_LEVEL_VERBOSE_2,
814 "AFSQueryBasicInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
815 &pCcb->DirectoryCB->NameInformation.FileName,
816 pCcb->DirectoryCB->ObjectInformation->FileType,
817 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
820 Buffer->CreationTime = DirectoryCB->ObjectInformation->CreationTime;
821 Buffer->LastAccessTime = DirectoryCB->ObjectInformation->LastAccessTime;
822 Buffer->LastWriteTime = DirectoryCB->ObjectInformation->LastWriteTime;
823 Buffer->ChangeTime = DirectoryCB->ObjectInformation->ChangeTime;
824 Buffer->FileAttributes = ulFileAttribs;
826 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
827 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
830 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
832 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
836 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
840 *Length -= sizeof( FILE_BASIC_INFORMATION);
845 ntStatus = STATUS_BUFFER_TOO_SMALL;
852 AFSQueryStandardInfo( IN PIRP Irp,
853 IN AFSDirectoryCB *DirectoryCB,
854 IN OUT PFILE_STANDARD_INFORMATION Buffer,
858 NTSTATUS ntStatus = STATUS_SUCCESS;
861 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
862 AFSFileInfoCB stFileInfo;
863 AFSDirectoryCB *pParentDirectoryCB = NULL;
864 UNICODE_STRING uniParentPath;
865 ULONG ulFileAttribs = 0;
867 if( *Length >= sizeof( FILE_STANDARD_INFORMATION))
870 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
871 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
873 RtlZeroMemory( Buffer,
876 Buffer->NumberOfLinks = 1;
877 Buffer->DeletePending = BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
879 Buffer->AllocationSize.QuadPart = (ULONGLONG)((DirectoryCB->ObjectInformation->AllocationSize.QuadPart/PAGE_SIZE) + 1) * PAGE_SIZE;
881 Buffer->EndOfFile = DirectoryCB->ObjectInformation->EndOfFile;
883 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
885 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
888 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
890 AFSRetrieveParentPath( &pCcb->FullFileName,
893 RtlZeroMemory( &stFileInfo,
894 sizeof( AFSFileInfoCB));
897 // Can't hold the Fcb while evaluating the path, leads to lock inversion
900 AFSReleaseResource( &pFcb->NPFcb->Resource);
902 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
909 ulFileAttribs = stFileInfo.FileAttributes;
912 AFSAcquireShared( &pFcb->NPFcb->Resource,
916 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
917 AFS_TRACE_LEVEL_VERBOSE_2,
918 "AFSQueryStandardInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
919 &pCcb->DirectoryCB->NameInformation.FileName,
920 pCcb->DirectoryCB->ObjectInformation->FileType,
921 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
924 Buffer->Directory = BooleanFlagOn( ulFileAttribs, FILE_ATTRIBUTE_DIRECTORY);
926 *Length -= sizeof( FILE_STANDARD_INFORMATION);
931 ntStatus = STATUS_BUFFER_TOO_SMALL;
938 AFSQueryInternalInfo( IN PIRP Irp,
940 IN OUT PFILE_INTERNAL_INFORMATION Buffer,
944 NTSTATUS ntStatus = STATUS_SUCCESS;
946 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
949 Buffer->IndexNumber.HighPart = Fcb->ObjectInformation->FileId.Volume;
951 Buffer->IndexNumber.LowPart = Fcb->ObjectInformation->FileId.Vnode;
953 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
958 ntStatus = STATUS_BUFFER_TOO_SMALL;
965 AFSQueryEaInfo( IN PIRP Irp,
966 IN AFSDirectoryCB *DirectoryCB,
967 IN OUT PFILE_EA_INFORMATION Buffer,
971 NTSTATUS ntStatus = STATUS_SUCCESS;
973 RtlZeroMemory( Buffer,
976 if( *Length >= sizeof( FILE_EA_INFORMATION))
981 *Length -= sizeof( FILE_EA_INFORMATION);
986 ntStatus = STATUS_BUFFER_TOO_SMALL;
993 AFSQueryPositionInfo( IN PIRP Irp,
995 IN OUT PFILE_POSITION_INFORMATION Buffer,
999 NTSTATUS ntStatus = STATUS_SUCCESS;
1000 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1002 if( *Length >= sizeof( FILE_POSITION_INFORMATION))
1005 RtlZeroMemory( Buffer,
1008 Buffer->CurrentByteOffset.QuadPart = pIrpSp->FileObject->CurrentByteOffset.QuadPart;
1010 *Length -= sizeof( FILE_POSITION_INFORMATION);
1015 ntStatus = STATUS_BUFFER_TOO_SMALL;
1022 AFSQueryAccess( IN PIRP Irp,
1024 IN OUT PFILE_ACCESS_INFORMATION Buffer,
1025 IN OUT PLONG Length)
1028 NTSTATUS ntStatus = STATUS_SUCCESS;
1030 if( *Length >= sizeof( FILE_ACCESS_INFORMATION))
1033 RtlZeroMemory( Buffer,
1036 Buffer->AccessFlags = 0;
1038 *Length -= sizeof( FILE_ACCESS_INFORMATION);
1043 ntStatus = STATUS_BUFFER_TOO_SMALL;
1050 AFSQueryMode( IN PIRP Irp,
1052 IN OUT PFILE_MODE_INFORMATION Buffer,
1053 IN OUT PLONG Length)
1056 NTSTATUS ntStatus = STATUS_SUCCESS;
1058 if( *Length >= sizeof( FILE_MODE_INFORMATION))
1061 RtlZeroMemory( Buffer,
1066 *Length -= sizeof( FILE_MODE_INFORMATION);
1071 ntStatus = STATUS_BUFFER_TOO_SMALL;
1078 AFSQueryAlignment( IN PIRP Irp,
1080 IN OUT PFILE_ALIGNMENT_INFORMATION Buffer,
1081 IN OUT PLONG Length)
1084 NTSTATUS ntStatus = STATUS_SUCCESS;
1086 if( *Length >= sizeof( FILE_ALIGNMENT_INFORMATION))
1089 RtlZeroMemory( Buffer,
1092 Buffer->AlignmentRequirement = 1;
1094 *Length -= sizeof( FILE_ALIGNMENT_INFORMATION);
1099 ntStatus = STATUS_BUFFER_TOO_SMALL;
1106 AFSQueryNameInfo( IN PIRP Irp,
1107 IN AFSDirectoryCB *DirectoryCB,
1108 IN OUT PFILE_NAME_INFORMATION Buffer,
1109 IN OUT PLONG Length)
1112 NTSTATUS ntStatus = STATUS_SUCCESS;
1113 ULONG ulCopyLength = 0;
1114 ULONG cchCopied = 0;
1115 AFSFcb *pFcb = NULL;
1116 AFSCcb *pCcb = NULL;
1117 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1118 BOOLEAN bAddLeadingSlash = FALSE;
1119 BOOLEAN bAddTrailingSlash = FALSE;
1120 USHORT usFullNameLength = 0;
1122 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1124 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1126 if( *Length >= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1129 RtlZeroMemory( Buffer,
1132 if( pCcb->FullFileName.Length == 0 ||
1133 pCcb->FullFileName.Buffer[ 0] != L'\\')
1135 bAddLeadingSlash = TRUE;
1138 if( pFcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
1139 pCcb->FullFileName.Length > 0 &&
1140 pCcb->FullFileName.Buffer[ (pCcb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\')
1142 bAddTrailingSlash = TRUE;
1145 usFullNameLength = sizeof( WCHAR) +
1146 AFSServerName.Length +
1147 pCcb->FullFileName.Length;
1149 if( bAddLeadingSlash)
1151 usFullNameLength += sizeof( WCHAR);
1154 if( bAddTrailingSlash)
1156 usFullNameLength += sizeof( WCHAR);
1159 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1162 ulCopyLength = (LONG)usFullNameLength;
1167 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1169 ntStatus = STATUS_BUFFER_OVERFLOW;
1172 Buffer->FileNameLength = (ULONG)usFullNameLength;
1174 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1176 if( ulCopyLength > 0)
1179 Buffer->FileName[ 0] = L'\\';
1180 ulCopyLength -= sizeof( WCHAR);
1182 *Length -= sizeof( WCHAR);
1185 if( ulCopyLength >= AFSServerName.Length)
1188 RtlCopyMemory( &Buffer->FileName[ 1],
1189 AFSServerName.Buffer,
1190 AFSServerName.Length);
1192 ulCopyLength -= AFSServerName.Length;
1193 *Length -= AFSServerName.Length;
1194 cchCopied += AFSServerName.Length/sizeof( WCHAR);
1196 if ( ulCopyLength > 0 &&
1200 Buffer->FileName[ cchCopied] = L'\\';
1202 ulCopyLength -= sizeof( WCHAR);
1203 *Length -= sizeof( WCHAR);
1207 if( ulCopyLength >= pCcb->FullFileName.Length)
1210 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1211 pCcb->FullFileName.Buffer,
1212 pCcb->FullFileName.Length);
1214 ulCopyLength -= pCcb->FullFileName.Length;
1215 *Length -= pCcb->FullFileName.Length;
1216 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1218 if( ulCopyLength > 0 &&
1221 Buffer->FileName[ cchCopied] = L'\\';
1223 *Length -= sizeof( WCHAR);
1229 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1230 pCcb->FullFileName.Buffer,
1233 *Length -= ulCopyLength;
1241 ntStatus = STATUS_BUFFER_TOO_SMALL;
1248 AFSQueryShortNameInfo( IN PIRP Irp,
1249 IN AFSDirectoryCB *DirectoryCB,
1250 IN OUT PFILE_NAME_INFORMATION Buffer,
1251 IN OUT PLONG Length)
1254 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1255 ULONG ulCopyLength = 0;
1257 RtlZeroMemory( Buffer,
1260 if( DirectoryCB->NameInformation.ShortNameLength == 0)
1264 // The short name IS the long name
1267 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1270 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1273 ulCopyLength = (LONG)DirectoryCB->NameInformation.FileName.Length;
1275 ntStatus = STATUS_SUCCESS;
1280 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1282 ntStatus = STATUS_BUFFER_OVERFLOW;
1285 Buffer->FileNameLength = DirectoryCB->NameInformation.FileName.Length;
1287 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1289 if( ulCopyLength > 0)
1292 RtlCopyMemory( Buffer->FileName,
1293 DirectoryCB->NameInformation.FileName.Buffer,
1296 *Length -= ulCopyLength;
1303 if( *Length >= (LONG)FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
1306 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)DirectoryCB->NameInformation.FileName.Length))
1309 ulCopyLength = (LONG)DirectoryCB->NameInformation.ShortNameLength;
1311 ntStatus = STATUS_SUCCESS;
1316 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1318 ntStatus = STATUS_BUFFER_OVERFLOW;
1321 Buffer->FileNameLength = DirectoryCB->NameInformation.ShortNameLength;
1323 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
1325 if( ulCopyLength > 0)
1328 RtlCopyMemory( Buffer->FileName,
1329 DirectoryCB->NameInformation.ShortName,
1330 Buffer->FileNameLength);
1332 *Length -= ulCopyLength;
1341 AFSQueryNetworkInfo( IN PIRP Irp,
1342 IN AFSDirectoryCB *DirectoryCB,
1343 IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
1344 IN OUT PLONG Length)
1347 NTSTATUS ntStatus = STATUS_SUCCESS;
1348 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1349 AFSFcb *pFcb = NULL;
1350 AFSCcb *pCcb = NULL;
1351 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1352 AFSFileInfoCB stFileInfo;
1353 AFSDirectoryCB *pParentDirectoryCB = NULL;
1354 UNICODE_STRING uniParentPath;
1355 ULONG ulFileAttribs = 0;
1357 RtlZeroMemory( Buffer,
1360 if( *Length >= sizeof( FILE_NETWORK_OPEN_INFORMATION))
1363 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1365 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1366 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1368 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1371 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1373 AFSRetrieveParentPath( &pCcb->FullFileName,
1376 RtlZeroMemory( &stFileInfo,
1377 sizeof( AFSFileInfoCB));
1380 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1383 AFSReleaseResource( &pFcb->NPFcb->Resource);
1385 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1392 ulFileAttribs = stFileInfo.FileAttributes;
1394 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1397 AFSAcquireShared( &pFcb->NPFcb->Resource,
1401 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1402 AFS_TRACE_LEVEL_VERBOSE_2,
1403 "AFSQueryNetworkInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1404 &pCcb->DirectoryCB->NameInformation.FileName,
1405 pCcb->DirectoryCB->ObjectInformation->FileType,
1406 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1409 Buffer->CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1410 Buffer->LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1411 Buffer->LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1412 Buffer->ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1414 Buffer->AllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1415 Buffer->EndOfFile.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1417 Buffer->FileAttributes = ulFileAttribs;
1419 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1420 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1423 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1426 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1431 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1435 *Length -= sizeof( FILE_NETWORK_OPEN_INFORMATION);
1440 ntStatus = STATUS_BUFFER_TOO_SMALL;
1447 AFSQueryStreamInfo( IN PIRP Irp,
1448 IN AFSDirectoryCB *DirectoryCB,
1449 IN OUT FILE_STREAM_INFORMATION *Buffer,
1450 IN OUT PLONG Length)
1453 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1454 ULONG ulCopyLength = 0;
1455 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1457 if( *Length >= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName))
1460 RtlZeroMemory( Buffer,
1463 Buffer->NextEntryOffset = 0;
1466 if( !BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1469 if( *Length >= (LONG)(FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName) + 14)) // ::$DATA
1474 ntStatus = STATUS_SUCCESS;
1479 ulCopyLength = *Length - FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1481 ntStatus = STATUS_BUFFER_OVERFLOW;
1484 Buffer->StreamNameLength = 14; // ::$DATA
1486 Buffer->StreamSize.QuadPart = DirectoryCB->ObjectInformation->EndOfFile.QuadPart;
1488 Buffer->StreamAllocationSize.QuadPart = DirectoryCB->ObjectInformation->AllocationSize.QuadPart;
1490 *Length -= FIELD_OFFSET( FILE_STREAM_INFORMATION, StreamName);
1492 if( ulCopyLength > 0)
1495 RtlCopyMemory( Buffer->StreamName,
1499 *Length -= ulCopyLength;
1505 Buffer->StreamNameLength = 0; // No stream for a directory
1507 // The response size is zero
1509 ntStatus = STATUS_SUCCESS;
1517 AFSQueryAttribTagInfo( IN PIRP Irp,
1518 IN AFSDirectoryCB *DirectoryCB,
1519 IN OUT FILE_ATTRIBUTE_TAG_INFORMATION *Buffer,
1520 IN OUT PLONG Length)
1523 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1524 ULONG ulCopyLength = 0;
1525 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1526 AFSFcb *pFcb = NULL;
1527 AFSCcb *pCcb = NULL;
1528 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1529 AFSFileInfoCB stFileInfo;
1530 AFSDirectoryCB *pParentDirectoryCB = NULL;
1531 UNICODE_STRING uniParentPath;
1532 ULONG ulFileAttribs = 0;
1534 if( *Length >= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION))
1537 RtlZeroMemory( Buffer,
1540 ulFileAttribs = DirectoryCB->ObjectInformation->FileAttributes;
1542 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1543 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1545 if( DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
1548 pParentDirectoryCB = AFSGetParentEntry( pCcb->NameArray);
1550 AFSRetrieveParentPath( &pCcb->FullFileName,
1553 RtlZeroMemory( &stFileInfo,
1554 sizeof( AFSFileInfoCB));
1557 // Can't hold the Fcb while evaluating the path, leads to lock inversion
1560 AFSReleaseResource( &pFcb->NPFcb->Resource);
1562 if( NT_SUCCESS( AFSRetrieveFileAttributes( pParentDirectoryCB,
1569 ulFileAttribs = stFileInfo.FileAttributes;
1571 ulFileAttribs |= FILE_ATTRIBUTE_REPARSE_POINT;
1574 AFSAcquireShared( &pFcb->NPFcb->Resource,
1578 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1579 AFS_TRACE_LEVEL_VERBOSE_2,
1580 "AFSAttribTagInfo %wZ Type 0x%x Attrib 0x%x -> 0x%x\n",
1581 &pCcb->DirectoryCB->NameInformation.FileName,
1582 pCcb->DirectoryCB->ObjectInformation->FileType,
1583 pCcb->DirectoryCB->ObjectInformation->FileAttributes,
1586 Buffer->FileAttributes = ulFileAttribs;
1588 if( DirectoryCB->NameInformation.FileName.Buffer[ 0] == L'.' &&
1589 BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES))
1592 if ( Buffer->FileAttributes != FILE_ATTRIBUTE_NORMAL)
1595 Buffer->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1600 Buffer->FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1604 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT))
1606 Buffer->ReparseTag = IO_REPARSE_TAG_OPENAFS_DFS;
1609 *Length -= sizeof( FILE_ATTRIBUTE_TAG_INFORMATION);
1611 ntStatus = STATUS_SUCCESS;
1618 AFSQueryRemoteProtocolInfo( IN PIRP Irp,
1619 IN AFSDirectoryCB *DirectoryCB,
1620 IN OUT FILE_REMOTE_PROTOCOL_INFORMATION *Buffer,
1621 IN OUT PLONG Length)
1624 NTSTATUS ntStatus = STATUS_BUFFER_TOO_SMALL;
1625 ULONG ulCopyLength = 0;
1626 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1628 if( *Length >= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION))
1631 RtlZeroMemory( Buffer,
1634 Buffer->StructureVersion = 1;
1636 Buffer->StructureSize = sizeof(FILE_REMOTE_PROTOCOL_INFORMATION);
1638 Buffer->Protocol = WNNC_NET_OPENAFS;
1640 Buffer->ProtocolMajorVersion = 3;
1642 Buffer->ProtocolMinorVersion = 0;
1644 Buffer->ProtocolRevision = 0;
1646 *Length -= sizeof( FILE_REMOTE_PROTOCOL_INFORMATION);
1648 ntStatus = STATUS_SUCCESS;
1655 AFSQueryPhysicalNameInfo( IN PIRP Irp,
1656 IN AFSDirectoryCB *DirectoryCB,
1657 IN OUT PFILE_NETWORK_PHYSICAL_NAME_INFORMATION Buffer,
1658 IN OUT PLONG Length)
1661 NTSTATUS ntStatus = STATUS_SUCCESS;
1662 ULONG ulCopyLength = 0;
1663 ULONG cchCopied = 0;
1664 AFSFcb *pFcb = NULL;
1665 AFSCcb *pCcb = NULL;
1666 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1667 BOOLEAN bAddLeadingSlash = FALSE;
1668 USHORT usFullNameLength = 0;
1670 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1672 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1674 if( *Length >= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName))
1677 RtlZeroMemory( Buffer,
1680 if( pCcb->FullFileName.Length == 0 ||
1681 pCcb->FullFileName.Buffer[ 0] != L'\\')
1683 bAddLeadingSlash = TRUE;
1686 usFullNameLength = pCcb->FullFileName.Length;
1688 if( bAddLeadingSlash)
1690 usFullNameLength += sizeof( WCHAR);
1693 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
1695 ulCopyLength = (LONG)usFullNameLength;
1700 ulCopyLength = *Length - FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1702 ntStatus = STATUS_BUFFER_OVERFLOW;
1705 Buffer->FileNameLength = (ULONG)usFullNameLength;
1707 *Length -= FIELD_OFFSET( FILE_NETWORK_PHYSICAL_NAME_INFORMATION, FileName);
1709 if( ulCopyLength > 0)
1712 if( bAddLeadingSlash)
1715 Buffer->FileName[ cchCopied] = L'\\';
1717 ulCopyLength -= sizeof( WCHAR);
1718 *Length -= sizeof( WCHAR);
1722 if( ulCopyLength >= pCcb->FullFileName.Length)
1725 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1726 pCcb->FullFileName.Buffer,
1727 pCcb->FullFileName.Length);
1729 ulCopyLength -= pCcb->FullFileName.Length;
1730 *Length -= pCcb->FullFileName.Length;
1731 cchCopied += pCcb->FullFileName.Length/sizeof( WCHAR);
1736 RtlCopyMemory( &Buffer->FileName[ cchCopied],
1737 pCcb->FullFileName.Buffer,
1740 *Length -= ulCopyLength;
1747 ntStatus = STATUS_BUFFER_TOO_SMALL;
1754 AFSSetBasicInfo( IN PIRP Irp,
1755 IN AFSDirectoryCB *DirectoryCB)
1757 NTSTATUS ntStatus = STATUS_SUCCESS;
1758 PFILE_BASIC_INFORMATION pBuffer;
1759 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1760 ULONG ulNotifyFilter = 0;
1761 AFSCcb *pCcb = NULL;
1766 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1768 pBuffer = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1770 pCcb->FileUnwindInfo.FileAttributes = (ULONG)-1;
1772 if( pBuffer->FileAttributes != (ULONGLONG)0)
1775 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_FILE_FCB &&
1776 BooleanFlagOn( pBuffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
1779 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1782 if( DirectoryCB->ObjectInformation->Fcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1785 pBuffer->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
1788 pCcb->FileUnwindInfo.FileAttributes = DirectoryCB->ObjectInformation->FileAttributes;
1790 DirectoryCB->ObjectInformation->FileAttributes = pBuffer->FileAttributes;
1792 ulNotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1794 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1797 pCcb->FileUnwindInfo.CreationTime.QuadPart = (ULONGLONG)-1;
1799 if( pBuffer->CreationTime.QuadPart != (ULONGLONG)-1 &&
1800 pBuffer->CreationTime.QuadPart != (ULONGLONG)0)
1803 pCcb->FileUnwindInfo.CreationTime.QuadPart = DirectoryCB->ObjectInformation->CreationTime.QuadPart;
1805 DirectoryCB->ObjectInformation->CreationTime.QuadPart = pBuffer->CreationTime.QuadPart;
1807 ulNotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
1809 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1812 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = (ULONGLONG)-1;
1814 if( pBuffer->LastAccessTime.QuadPart != (ULONGLONG)-1 &&
1815 pBuffer->LastAccessTime.QuadPart != (ULONGLONG)0)
1818 pCcb->FileUnwindInfo.LastAccessTime.QuadPart = DirectoryCB->ObjectInformation->LastAccessTime.QuadPart;
1820 DirectoryCB->ObjectInformation->LastAccessTime.QuadPart = pBuffer->LastAccessTime.QuadPart;
1822 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1824 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1827 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = (ULONGLONG)-1;
1829 if( pBuffer->LastWriteTime.QuadPart != (ULONGLONG)-1 &&
1830 pBuffer->LastWriteTime.QuadPart != (ULONGLONG)0)
1833 pCcb->FileUnwindInfo.LastWriteTime.QuadPart = DirectoryCB->ObjectInformation->LastWriteTime.QuadPart;
1835 DirectoryCB->ObjectInformation->LastWriteTime.QuadPart = pBuffer->LastWriteTime.QuadPart;
1837 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
1839 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME);
1842 pCcb->FileUnwindInfo.ChangeTime.QuadPart = (ULONGLONG)-1;
1844 if( pBuffer->ChangeTime.QuadPart != (ULONGLONG)-1 &&
1845 pBuffer->ChangeTime.QuadPart != (ULONGLONG)0)
1848 pCcb->FileUnwindInfo.ChangeTime.QuadPart = DirectoryCB->ObjectInformation->ChangeTime.QuadPart;
1850 DirectoryCB->ObjectInformation->ChangeTime.QuadPart = pBuffer->ChangeTime.QuadPart;
1852 ulNotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
1854 SetFlag( DirectoryCB->ObjectInformation->Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1857 if( ulNotifyFilter > 0)
1860 if( DirectoryCB->ObjectInformation->ParentObjectInformation != NULL)
1863 AFSFsRtlNotifyFullReportChange( DirectoryCB->ObjectInformation->ParentObjectInformation,
1865 (ULONG)ulNotifyFilter,
1866 (ULONG)FILE_ACTION_MODIFIED);
1879 AFSSetDispositionInfo( IN PIRP Irp,
1880 IN AFSDirectoryCB *DirectoryCB)
1882 NTSTATUS ntStatus = STATUS_SUCCESS;
1883 PFILE_DISPOSITION_INFORMATION pBuffer;
1884 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1885 AFSFcb *pFcb = NULL;
1886 AFSCcb *pCcb = NULL;
1891 pBuffer = (PFILE_DISPOSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1893 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1895 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1898 // Can't delete the root
1901 if( pFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
1904 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1905 AFS_TRACE_LEVEL_ERROR,
1906 "AFSSetDispositionInfo Attempt to delete root entry\n");
1908 try_return( ntStatus = STATUS_CANNOT_DELETE);
1912 // If the file is read only then do not allow the delete
1915 if( BooleanFlagOn( DirectoryCB->ObjectInformation->FileAttributes, FILE_ATTRIBUTE_READONLY))
1918 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1919 AFS_TRACE_LEVEL_ERROR,
1920 "AFSSetDispositionInfo Attempt to delete read only entry %wZ\n",
1921 &DirectoryCB->NameInformation.FileName);
1923 try_return( ntStatus = STATUS_CANNOT_DELETE);
1926 if( pBuffer->DeleteFile)
1930 // Check if the caller can delete the file
1933 ntStatus = AFSNotifyDelete( DirectoryCB,
1937 if( !NT_SUCCESS( ntStatus))
1940 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1941 AFS_TRACE_LEVEL_ERROR,
1942 "AFSSetDispositionInfo Cannot delete entry %wZ Status %08lX\n",
1943 &DirectoryCB->NameInformation.FileName,
1946 try_return( ntStatus);
1949 if( pFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
1953 // Check if this is a directory that there are not currently other opens
1956 if( pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
1959 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1960 AFS_TRACE_LEVEL_ERROR,
1961 "AFSSetDispositionInfo Attempt to delete directory %wZ with open %u handles\n",
1962 &DirectoryCB->NameInformation.FileName,
1963 pFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount);
1965 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
1968 if( !AFSIsDirectoryEmptyForDelete( pFcb))
1971 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1972 AFS_TRACE_LEVEL_ERROR,
1973 "AFSSetDispositionInfo Attempt to delete non-empty directory %wZ\n",
1974 &DirectoryCB->NameInformation.FileName);
1976 try_return( ntStatus = STATUS_DIRECTORY_NOT_EMPTY);
1983 // Attempt to flush any outstanding data
1986 if( !MmFlushImageSection( &pFcb->NPFcb->SectionObjectPointers,
1990 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1991 AFS_TRACE_LEVEL_ERROR,
1992 "AFSSetDispositionInfo Failed to flush image section for delete Entry %wZ\n",
1993 &DirectoryCB->NameInformation.FileName);
1995 try_return( ntStatus = STATUS_CANNOT_DELETE);
1999 // Purge the cache as well
2002 if( pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
2005 CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
2012 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2013 AFS_TRACE_LEVEL_VERBOSE,
2014 "AFSSetDispositionInfo Setting PENDING_DELETE on DirEntry %p Name %wZ\n",
2016 &DirectoryCB->NameInformation.FileName);
2018 SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2023 ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
2027 // OK, should be good to go, set the flag in the file object
2030 pIrpSp->FileObject->DeletePending = pBuffer->DeleteFile;
2041 AFSSetRenameInfo( IN PIRP Irp)
2044 NTSTATUS ntStatus = STATUS_SUCCESS;
2045 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2046 IO_STATUS_BLOCK stIoSb = {0,0};
2047 AFSFcb *pSrcFcb = NULL, *pTargetDcb = NULL, *pTargetFcb = NULL;
2048 AFSCcb *pSrcCcb = NULL, *pTargetDirCcb = NULL;
2049 PFILE_OBJECT pSrcFileObj = pIrpSp->FileObject;
2050 PFILE_OBJECT pTargetFileObj = pIrpSp->Parameters.SetFile.FileObject;
2051 PFILE_RENAME_INFORMATION pRenameInfo = NULL;
2052 UNICODE_STRING uniTargetName, uniSourceName;
2053 BOOLEAN bReplaceIfExists = FALSE;
2054 UNICODE_STRING uniShortName;
2055 AFSDirectoryCB *pTargetDirEntry = NULL;
2056 ULONG ulTargetCRC = 0;
2057 BOOLEAN bTargetEntryExists = FALSE;
2058 AFSObjectInfoCB *pSrcObject = NULL, *pTargetObject = NULL;
2059 AFSObjectInfoCB *pSrcParentObject = NULL, *pTargetParentObject = NULL;
2060 AFSFileID stNewFid, stTmpTargetFid;
2061 ULONG ulNotificationAction = 0, ulNotifyFilter = 0;
2062 UNICODE_STRING uniFullTargetPath;
2063 BOOLEAN bCommonParent = FALSE;
2064 BOOLEAN bReleaseTargetDirLock = FALSE;
2065 BOOLEAN bReleaseSourceDirLock = FALSE;
2066 PERESOURCE pSourceDirLock = NULL;
2071 bReplaceIfExists = pIrpSp->Parameters.SetFile.ReplaceIfExists;
2073 pSrcFcb = (AFSFcb *)pSrcFileObj->FsContext;
2074 pSrcCcb = (AFSCcb *)pSrcFileObj->FsContext2;
2076 pSrcObject = pSrcFcb->ObjectInformation;
2079 // Perform some basic checks to ensure FS integrity
2082 if( pSrcFcb->Header.NodeTypeCode == AFS_ROOT_FCB)
2086 // Can't rename the root directory
2089 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2090 AFS_TRACE_LEVEL_ERROR,
2091 "AFSSetRenameInfo Attempt to rename root entry\n");
2093 try_return( ntStatus = STATUS_INVALID_PARAMETER);
2096 if( pSrcFcb->Header.NodeTypeCode == AFS_DIRECTORY_FCB)
2100 // If there are any open children then fail the rename
2103 if( pSrcFcb->ObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
2106 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2107 AFS_TRACE_LEVEL_ERROR,
2108 "AFSSetRenameInfo Attempt to rename directory with open children %wZ\n",
2109 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2111 try_return( ntStatus = STATUS_ACCESS_DENIED);
2117 if( pSrcFcb->OpenHandleCount > 1)
2120 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2121 AFS_TRACE_LEVEL_ERROR,
2122 "AFSSetRenameInfo Attempt to rename directory with open references %wZ\n",
2123 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2125 try_return( ntStatus = STATUS_ACCESS_DENIED);
2130 // Resolve the target fileobject
2133 if( pTargetFileObj == NULL)
2137 // This is a simple rename. Here the target directory is the same as the source parent directory
2138 // and the name is retrieved from the system buffer information
2141 pRenameInfo = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2143 pTargetParentObject = pSrcFcb->ObjectInformation->ParentObjectInformation;
2145 pTargetDcb = pTargetParentObject->Fcb;
2147 uniTargetName.Length = (USHORT)pRenameInfo->FileNameLength;
2148 uniTargetName.Buffer = (PWSTR)&pRenameInfo->FileName;
2154 // So here we have the target directory taken from the targetfile object
2157 pTargetDcb = (AFSFcb *)pTargetFileObj->FsContext;
2159 pTargetDirCcb = (AFSCcb *)pTargetFileObj->FsContext2;
2161 pTargetParentObject = (AFSObjectInfoCB *)pTargetDcb->ObjectInformation;
2164 // Grab the target name which we setup in the IRP_MJ_CREATE handler. By how we set this up
2165 // it is only the target component of the rename operation
2168 uniTargetName = *((PUNICODE_STRING)&pTargetFileObj->FileName);
2172 // We do not allow cross-volume renames to occur
2175 if( pTargetParentObject->VolumeCB != pSrcObject->VolumeCB)
2178 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2179 AFS_TRACE_LEVEL_ERROR,
2180 "AFSSetRenameInfo Attempt to rename directory to different volume %wZ\n",
2181 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2183 try_return( ntStatus = STATUS_NOT_SAME_DEVICE);
2186 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2189 AFSAcquireExcl( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
2192 bReleaseTargetDirLock = TRUE;
2194 if( pTargetParentObject != pSrcFcb->ObjectInformation->ParentObjectInformation)
2196 AFSAcquireExcl( pSrcFcb->ObjectInformation->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
2199 bReleaseSourceDirLock = TRUE;
2201 pSourceDirLock = pSrcFcb->ObjectInformation->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock;
2204 AFSLocateCaseSensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
2208 if( pTargetDirEntry == NULL)
2212 // Missed so perform a case insensitive lookup
2215 ulTargetCRC = AFSGenerateCRC( &uniTargetName,
2218 AFSLocateCaseInsensitiveDirEntry( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
2223 if( pTargetDirEntry == NULL && RtlIsNameLegalDOS8Dot3( &uniTargetName,
2228 // Try the short name
2230 AFSLocateShortNameDirEntry( pTargetParentObject->Specific.Directory.ShortNameTree,
2236 // Increment our ref count on the dir entry
2239 if( pTargetDirEntry != NULL)
2242 ASSERT( pTargetParentObject == pTargetDirEntry->ObjectInformation->ParentObjectInformation);
2244 InterlockedIncrement( &pTargetDirEntry->OpenReferenceCount);
2246 if( !bReplaceIfExists)
2249 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2250 AFS_TRACE_LEVEL_ERROR,
2251 "AFSSetRenameInfo Attempt to rename directory with target collision %wZ Target %wZ\n",
2252 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2253 &pTargetDirEntry->NameInformation.FileName);
2255 try_return( ntStatus = STATUS_OBJECT_NAME_COLLISION);
2258 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2259 AFS_TRACE_LEVEL_ERROR,
2260 "AFSSetRenameInfo Target %wZ exists DE %p Count %08lX, performing delete of target\n",
2261 &pTargetDirEntry->NameInformation.FileName,
2263 pTargetDirEntry->OpenReferenceCount);
2266 // Pull the directory entry from the parent
2269 AFSRemoveDirNodeFromParent( pTargetParentObject,
2273 bTargetEntryExists = TRUE;
2277 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2278 AFS_TRACE_LEVEL_VERBOSE,
2279 "AFSSetRenameInfo Target does NOT exist, normal rename\n");
2283 // Extract off the final component name from the Fcb
2286 uniSourceName.Length = (USHORT)pSrcCcb->DirectoryCB->NameInformation.FileName.Length;
2287 uniSourceName.MaximumLength = uniSourceName.Length;
2289 uniSourceName.Buffer = pSrcCcb->DirectoryCB->NameInformation.FileName.Buffer;
2292 // The quick check to see if they are not really performing a rename
2293 // Do the names match? Only do this where the parent directories are
2297 if( pTargetParentObject == pSrcFcb->ObjectInformation->ParentObjectInformation)
2300 bCommonParent = TRUE;
2302 if( FsRtlAreNamesEqual( &uniTargetName,
2307 try_return( ntStatus = STATUS_SUCCESS);
2313 bCommonParent = FALSE;
2317 // We need to remove the DirEntry from the parent node, update the index
2318 // and reinsert it into the parent tree. Note that for entries with the
2319 // same parent we do not pull the node from the enumeration list
2322 AFSRemoveDirNodeFromParent( pSrcFcb->ObjectInformation->ParentObjectInformation,
2323 pSrcCcb->DirectoryCB,
2327 // OK, this is a simple rename. Issue the rename
2328 // request to the service.
2331 ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
2332 &pSrcCcb->AuthGroup,
2333 pSrcFcb->ObjectInformation->ParentObjectInformation,
2334 pTargetDcb->ObjectInformation,
2335 pSrcCcb->DirectoryCB,
2339 if( !NT_SUCCESS( ntStatus))
2343 // Attempt to re-insert the directory entry
2346 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2347 pSrcCcb->DirectoryCB,
2350 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2351 AFS_TRACE_LEVEL_ERROR,
2352 "AFSSetRenameInfo Failed rename of %wZ to target %wZ Status %08lX\n",
2353 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2357 try_return( ntStatus);
2361 // Set the notification up for the source file
2364 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation == pTargetParentObject &&
2365 !bTargetEntryExists)
2368 ulNotificationAction = FILE_ACTION_RENAMED_OLD_NAME;
2373 ulNotificationAction = FILE_ACTION_REMOVED;
2376 if( pSrcCcb->DirectoryCB->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
2379 ulNotifyFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
2384 ulNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
2387 AFSFsRtlNotifyFullReportChange( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation,
2389 (ULONG)ulNotifyFilter,
2390 (ULONG)ulNotificationAction);
2393 // Update the name in the dir entry.
2396 ntStatus = AFSUpdateDirEntryName( pSrcCcb->DirectoryCB,
2399 if( !NT_SUCCESS( ntStatus))
2403 // Attempt to re-insert the directory entry
2406 AFSInsertDirectoryNode( pSrcFcb->ObjectInformation->ParentObjectInformation,
2407 pSrcCcb->DirectoryCB,
2410 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2411 AFS_TRACE_LEVEL_ERROR,
2412 "AFSSetRenameInfo Failed update of dir entry %wZ to target %wZ Status %08lX\n",
2413 &pSrcCcb->DirectoryCB->NameInformation.FileName,
2417 try_return( ntStatus);
2421 // Update the object information block, if needed
2424 if( !AFSIsEqualFID( &pSrcObject->FileId,
2428 AFSAcquireExcl( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock,
2432 // Remove the old information entry
2435 AFSRemoveHashEntry( &pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2436 &pSrcObject->TreeEntry);
2438 RtlCopyMemory( &pSrcObject->FileId,
2440 sizeof( AFSFileID));
2443 // Insert the entry into the new object table.
2446 pSrcObject->TreeEntry.HashIndex = AFSCreateLowIndex( &pSrcObject->FileId);
2448 if( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead == NULL)
2451 pSrcObject->VolumeCB->ObjectInfoTree.TreeHead = &pSrcObject->TreeEntry;
2456 if ( !NT_SUCCESS( AFSInsertHashEntry( pSrcObject->VolumeCB->ObjectInfoTree.TreeHead,
2457 &pSrcObject->TreeEntry)))
2461 // Lost a race, an ObjectInfo object already exists for this FID.
2462 // Let this copy be garbage collected.
2465 ClearFlag( pSrcObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
2469 AFSReleaseResource( pSrcObject->VolumeCB->ObjectInfoTree.TreeLock);
2473 // Update the hash values for the name trees.
2476 pSrcCcb->DirectoryCB->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2479 pSrcCcb->DirectoryCB->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2482 if( pSrcCcb->DirectoryCB->NameInformation.ShortNameLength > 0 &&
2483 !RtlIsNameLegalDOS8Dot3( &pSrcCcb->DirectoryCB->NameInformation.FileName,
2488 uniShortName.Length = pSrcCcb->DirectoryCB->NameInformation.ShortNameLength;
2489 uniShortName.MaximumLength = uniShortName.Length;
2490 uniShortName.Buffer = pSrcCcb->DirectoryCB->NameInformation.ShortName;
2492 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
2495 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2496 AFS_TRACE_LEVEL_VERBOSE,
2497 "AFSSetRenameInfo Initialized short name hash for %wZ longname %wZ\n",
2499 &pSrcCcb->DirectoryCB->NameInformation.FileName);
2504 pSrcCcb->DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
2511 // Update the file index for the object in the new parent
2514 pSrcCcb->DirectoryCB->FileIndex = (ULONG)InterlockedIncrement( &pTargetParentObject->Specific.Directory.DirectoryNodeHdr.ContentIndex);
2518 // Re-insert the directory entry
2521 AFSInsertDirectoryNode( pTargetParentObject,
2522 pSrcCcb->DirectoryCB,
2526 // Update the parent pointer in the source object if they are different
2529 if( pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation != pTargetParentObject)
2532 InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
2534 InterlockedDecrement( &pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
2536 InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenHandleCount);
2538 InterlockedIncrement( &pTargetParentObject->Specific.Directory.ChildOpenReferenceCount);
2540 pSrcCcb->DirectoryCB->ObjectInformation->ParentObjectInformation = pTargetParentObject;
2542 ulNotificationAction = FILE_ACTION_ADDED;
2547 ulNotificationAction = FILE_ACTION_RENAMED_NEW_NAME;
2551 // Now update the notification for the target file
2554 AFSFsRtlNotifyFullReportChange( pTargetParentObject->ParentObjectInformation,
2556 (ULONG)ulNotifyFilter,
2557 (ULONG)ulNotificationAction);
2560 // If we performed the rename of the target because it existed, we now need to
2561 // delete the tmp target we created above
2564 if( bTargetEntryExists)
2567 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2568 AFS_TRACE_LEVEL_VERBOSE,
2569 "AFSSetRenameInfo Setting DELETE flag in dir entry %p name %wZ\n",
2571 &pTargetDirEntry->NameInformation.FileName);
2573 SetFlag( pTargetDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
2576 // Try and purge the cache map if this is a file
2579 if( pTargetDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
2580 pTargetDirEntry->ObjectInformation->Fcb != NULL &&
2581 pTargetDirEntry->OpenReferenceCount > 1)
2584 pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
2586 AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
2590 // Close the section in the event it was mapped
2593 if( !MmForceSectionClosed( &pTargetFcb->NPFcb->SectionObjectPointers,
2597 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2598 AFS_TRACE_LEVEL_ERROR,
2599 "AFSSetRenameInfo Failed to delete section for target file %wZ\n",
2600 &pTargetDirEntry->NameInformation.FileName);
2603 AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
2606 ASSERT( pTargetDirEntry->OpenReferenceCount > 0);
2608 InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount); // The count we added above
2610 if( pTargetDirEntry->OpenReferenceCount == 0)
2613 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2614 AFS_TRACE_LEVEL_VERBOSE,
2615 "AFSSetRenameInfo Deleting dir entry %p name %wZ\n",
2617 &pTargetDirEntry->NameInformation.FileName);
2619 AFSDeleteDirEntry( pTargetParentObject,
2623 pTargetDirEntry = NULL;
2629 if( !NT_SUCCESS( ntStatus))
2632 if( bTargetEntryExists)
2634 AFSInsertDirectoryNode( pTargetDirEntry->ObjectInformation->ParentObjectInformation,
2640 if( pTargetDirEntry != NULL)
2643 InterlockedDecrement( &pTargetDirEntry->OpenReferenceCount);
2646 if( bReleaseTargetDirLock)
2648 AFSReleaseResource( pTargetParentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
2651 if( bReleaseSourceDirLock)
2653 AFSReleaseResource( pSourceDirLock);
2661 AFSSetPositionInfo( IN PIRP Irp,
2662 IN AFSDirectoryCB *DirectoryCB)
2664 NTSTATUS ntStatus = STATUS_SUCCESS;
2665 PFILE_POSITION_INFORMATION pBuffer;
2666 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2668 pBuffer = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2670 pIrpSp->FileObject->CurrentByteOffset.QuadPart = pBuffer->CurrentByteOffset.QuadPart;
2676 AFSSetAllocationInfo( IN PIRP Irp,
2677 IN AFSDirectoryCB *DirectoryCB)
2679 NTSTATUS ntStatus = STATUS_SUCCESS;
2680 PFILE_ALLOCATION_INFORMATION pBuffer;
2681 BOOLEAN bReleasePaging = FALSE;
2682 BOOLEAN bTellCc = FALSE;
2683 BOOLEAN bTellService = FALSE;
2684 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2685 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2686 AFSFcb *pFcb = NULL;
2687 AFSCcb *pCcb = NULL;
2688 LARGE_INTEGER liSaveAlloc;
2689 LARGE_INTEGER liSaveFileSize;
2690 LARGE_INTEGER liSaveVDL;
2692 pBuffer = (PFILE_ALLOCATION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2694 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2696 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2699 // save values to put back
2701 liSaveAlloc = pFcb->Header.AllocationSize;
2702 liSaveFileSize = pFcb->Header.FileSize;
2703 liSaveVDL = pFcb->Header.ValidDataLength;
2705 if( pFcb->Header.AllocationSize.QuadPart == pBuffer->AllocationSize.QuadPart ||
2706 pIrpSp->Parameters.SetFile.AdvanceOnly)
2708 return STATUS_SUCCESS ;
2711 if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2714 // Truncating the file
2716 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2717 &pBuffer->AllocationSize))
2720 ntStatus = STATUS_USER_MAPPED_FILE ;
2725 // If this is a truncation we need to grab the paging IO resource.
2727 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2728 AFS_TRACE_LEVEL_VERBOSE,
2729 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2730 &pFcb->NPFcb->PagingResource,
2731 PsGetCurrentThread());
2733 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2736 bReleasePaging = TRUE;
2739 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2741 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2744 // Tell Cc that Allocation is moved.
2748 if( pFcb->Header.FileSize.QuadPart > pBuffer->AllocationSize.QuadPart)
2751 // We are pulling the EOF back as well so we need to tell
2754 bTellService = TRUE;
2756 pFcb->Header.FileSize = pBuffer->AllocationSize;
2758 pFcb->ObjectInformation->EndOfFile = pBuffer->AllocationSize;
2766 // Tell Cc if allocation is increased.
2768 bTellCc = pBuffer->AllocationSize.QuadPart > pFcb->Header.AllocationSize.QuadPart;
2770 pFcb->Header.AllocationSize = pBuffer->AllocationSize;
2772 pFcb->ObjectInformation->AllocationSize = pBuffer->AllocationSize;
2776 // Now Tell the server if we have to
2780 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
2781 pFcb->ObjectInformation,
2785 if (NT_SUCCESS(ntStatus))
2788 // Trim extents if we told the service - the update has done an implicit
2789 // trim at the service.
2793 AFSTrimExtents( pFcb,
2794 &pFcb->Header.FileSize);
2797 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
2799 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2802 CcIsFileCached( pFileObject))
2804 CcSetFileSizes( pFileObject,
2805 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
2811 // Put the saved values back
2813 pFcb->Header.ValidDataLength = liSaveVDL;
2814 pFcb->Header.FileSize = liSaveFileSize;
2815 pFcb->Header.AllocationSize = liSaveAlloc;
2816 pFcb->ObjectInformation->EndOfFile = liSaveFileSize;
2817 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
2823 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
2830 AFSSetEndOfFileInfo( IN PIRP Irp,
2831 IN AFSDirectoryCB *DirectoryCB)
2833 NTSTATUS ntStatus = STATUS_SUCCESS;
2834 PFILE_END_OF_FILE_INFORMATION pBuffer;
2835 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2836 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
2837 LARGE_INTEGER liSaveSize;
2838 LARGE_INTEGER liSaveVDL;
2839 LARGE_INTEGER liSaveAlloc;
2840 BOOLEAN bModified = FALSE;
2841 BOOLEAN bReleasePaging = FALSE;
2842 BOOLEAN bTruncated = FALSE;
2843 AFSFcb *pFcb = NULL;
2844 AFSCcb *pCcb = NULL;
2846 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
2848 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
2850 pBuffer = (PFILE_END_OF_FILE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
2852 liSaveSize = pFcb->Header.FileSize;
2853 liSaveAlloc = pFcb->Header.AllocationSize;
2854 liSaveVDL = pFcb->Header.ValidDataLength;
2856 if( pFcb->Header.FileSize.QuadPart != pBuffer->EndOfFile.QuadPart &&
2857 !pIrpSp->Parameters.SetFile.AdvanceOnly)
2860 if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
2863 // Truncating the file
2864 if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
2865 &pBuffer->EndOfFile))
2868 ntStatus = STATUS_USER_MAPPED_FILE;
2873 // If this is a truncation we need to grab the paging
2876 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2877 AFS_TRACE_LEVEL_VERBOSE,
2878 "AFSSetAllocationInfo Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
2879 &pFcb->NPFcb->PagingResource,
2880 PsGetCurrentThread());
2882 AFSAcquireExcl( &pFcb->NPFcb->PagingResource,
2885 bReleasePaging = TRUE;
2887 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
2889 pFcb->Header.FileSize = pBuffer->EndOfFile;
2891 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
2893 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
2895 if( pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
2898 pFcb->Header.ValidDataLength = pFcb->Header.FileSize;
2909 // extending the file, move EOF
2912 pFcb->Header.FileSize = pBuffer->EndOfFile;
2914 pFcb->ObjectInformation->EndOfFile = pBuffer->EndOfFile;
2916 if (pFcb->Header.FileSize.QuadPart > pFcb->Header.AllocationSize.QuadPart)
2919 // And Allocation as needed.
2921 pFcb->Header.AllocationSize = pBuffer->EndOfFile;
2923 pFcb->ObjectInformation->AllocationSize = pBuffer->EndOfFile;
2933 KeQuerySystemTime( &pFcb->ObjectInformation->ChangeTime);
2935 SetFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
2941 ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
2942 pFcb->ObjectInformation,
2945 if( NT_SUCCESS(ntStatus))
2948 // We are now good to go so tell CC.
2950 CcSetFileSizes( pFileObject,
2951 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize);
2954 // And give up those extents
2959 AFSTrimExtents( pFcb,
2960 &pFcb->Header.FileSize);
2965 pFcb->Header.ValidDataLength = liSaveVDL;
2966 pFcb->Header.FileSize = liSaveSize;
2967 pFcb->Header.AllocationSize = liSaveAlloc;
2968 pFcb->ObjectInformation->EndOfFile = liSaveSize;
2969 pFcb->ObjectInformation->AllocationSize = liSaveAlloc;
2976 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
2983 AFSProcessShareSetInfo( IN IRP *Irp,
2988 NTSTATUS ntStatus = STATUS_SUCCESS;
2989 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2990 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
2991 FILE_INFORMATION_CLASS ulFileInformationClass;
2992 void *pPipeInfo = NULL;
2996 ulFileInformationClass = pIrpSp->Parameters.SetFile.FileInformationClass;
2998 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
2999 AFS_TRACE_LEVEL_VERBOSE,
3000 "AFSProcessShareSetInfo On pipe %wZ Class %08lX\n",
3001 &Ccb->DirectoryCB->NameInformation.FileName,
3002 ulFileInformationClass);
3004 pPipeInfo = AFSLockSystemBuffer( Irp,
3005 pIrpSp->Parameters.SetFile.Length);
3007 if( pPipeInfo == NULL)
3010 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3011 AFS_TRACE_LEVEL_ERROR,
3012 "AFSProcessShareSetInfo Failed to lock buffer on pipe %wZ\n",
3013 &Ccb->DirectoryCB->NameInformation.FileName);
3015 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3019 // Send the request to the service
3022 ntStatus = AFSNotifySetPipeInfo( Ccb,
3023 (ULONG)ulFileInformationClass,
3024 pIrpSp->Parameters.SetFile.Length,
3027 if( !NT_SUCCESS( ntStatus))
3030 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3031 AFS_TRACE_LEVEL_ERROR,
3032 "AFSProcessShareSetInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3033 &Ccb->DirectoryCB->NameInformation.FileName,
3036 try_return( ntStatus);
3039 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3040 AFS_TRACE_LEVEL_VERBOSE,
3041 "AFSProcessShareSetInfo Completed request on pipe %wZ Class %08lX\n",
3042 &Ccb->DirectoryCB->NameInformation.FileName,
3043 ulFileInformationClass);
3054 AFSProcessShareQueryInfo( IN IRP *Irp,
3059 NTSTATUS ntStatus = STATUS_SUCCESS;
3060 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3061 ULONG ulOutputBufferLen = 0, ulInputBufferLen;
3062 FILE_INFORMATION_CLASS ulFileInformationClass;
3063 void *pPipeInfo = NULL;
3068 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3070 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3071 AFS_TRACE_LEVEL_VERBOSE,
3072 "AFSProcessShareQueryInfo On pipe %wZ Class %08lX\n",
3073 &Ccb->DirectoryCB->NameInformation.FileName,
3074 ulFileInformationClass);
3076 pPipeInfo = AFSLockSystemBuffer( Irp,
3077 pIrpSp->Parameters.QueryFile.Length);
3079 if( pPipeInfo == NULL)
3082 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3083 AFS_TRACE_LEVEL_ERROR,
3084 "AFSProcessShareQueryInfo Failed to lock buffer on pipe %wZ\n",
3085 &Ccb->DirectoryCB->NameInformation.FileName);
3087 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
3091 // Send the request to the service
3094 ntStatus = AFSNotifyQueryPipeInfo( Ccb,
3095 (ULONG)ulFileInformationClass,
3096 pIrpSp->Parameters.QueryFile.Length,
3098 (ULONG *)&Irp->IoStatus.Information);
3100 if( !NT_SUCCESS( ntStatus))
3103 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3104 AFS_TRACE_LEVEL_ERROR,
3105 "AFSProcessShareQueryInfo Failed to send request to service on pipe %wZ Status %08lX\n",
3106 &Ccb->DirectoryCB->NameInformation.FileName,
3109 try_return( ntStatus);
3112 AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
3113 AFS_TRACE_LEVEL_VERBOSE,
3114 "AFSProcessShareQueryInfo Completed request on pipe %wZ Class %08lX\n",
3115 &Ccb->DirectoryCB->NameInformation.FileName,
3116 ulFileInformationClass);
3127 AFSProcessPIOCtlQueryInfo( IN IRP *Irp,
3130 IN OUT LONG *Length)
3133 NTSTATUS ntStatus = STATUS_SUCCESS;
3134 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
3135 FILE_INFORMATION_CLASS ulFileInformationClass;
3140 ulFileInformationClass = pIrpSp->Parameters.QueryFile.FileInformationClass;
3142 switch( ulFileInformationClass)
3145 case FileBasicInformation:
3148 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3149 AFS_TRACE_LEVEL_VERBOSE,
3150 "AFSProcessPIOCtlQueryInfo (FileBasicInformation)\n");
3152 if ( *Length >= sizeof( FILE_BASIC_INFORMATION))
3154 PFILE_BASIC_INFORMATION pBasic = (PFILE_BASIC_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3156 pBasic->CreationTime.QuadPart = 0;
3157 pBasic->LastAccessTime.QuadPart = 0;
3158 pBasic->ChangeTime.QuadPart = 0;
3159 pBasic->LastWriteTime.QuadPart = 0;
3160 pBasic->FileAttributes = FILE_ATTRIBUTE_SYSTEM;
3162 *Length -= sizeof( FILE_BASIC_INFORMATION);
3166 ntStatus = STATUS_BUFFER_TOO_SMALL;
3172 case FileStandardInformation:
3175 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3176 AFS_TRACE_LEVEL_VERBOSE,
3177 "AFSProcessPIOCtlQueryInfo (FileStandardInformation)\n");
3179 if ( *Length >= sizeof( FILE_STANDARD_INFORMATION))
3181 PFILE_STANDARD_INFORMATION pStandard = (PFILE_STANDARD_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3183 pStandard->NumberOfLinks = 1;
3184 pStandard->DeletePending = 0;
3185 pStandard->AllocationSize.QuadPart = 0;
3186 pStandard->EndOfFile.QuadPart = 0;
3187 pStandard->Directory = 0;
3189 *Length -= sizeof( FILE_STANDARD_INFORMATION);
3193 ntStatus = STATUS_BUFFER_TOO_SMALL;
3199 case FileNameInformation:
3202 ULONG ulCopyLength = 0;
3203 AFSFcb *pFcb = NULL;
3204 AFSCcb *pCcb = NULL;
3205 USHORT usFullNameLength = 0;
3206 PFILE_NAME_INFORMATION pNameInfo = (PFILE_NAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3207 UNICODE_STRING uniName;
3209 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3210 AFS_TRACE_LEVEL_VERBOSE,
3211 "AFSProcessPIOCtlQueryInfo (FileNameInformation)\n");
3213 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
3214 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
3216 if( *Length < FIELD_OFFSET( FILE_NAME_INFORMATION, FileName))
3218 ntStatus = STATUS_BUFFER_TOO_SMALL;
3222 RtlZeroMemory( pNameInfo,
3225 usFullNameLength = sizeof( WCHAR) +
3226 AFSServerName.Length +
3227 pCcb->FullFileName.Length;
3229 if( *Length >= (LONG)(FIELD_OFFSET( FILE_NAME_INFORMATION, FileName) + (LONG)usFullNameLength))
3231 ulCopyLength = (LONG)usFullNameLength;
3235 ulCopyLength = *Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3236 ntStatus = STATUS_BUFFER_OVERFLOW;
3239 pNameInfo->FileNameLength = (ULONG)usFullNameLength;
3241 *Length -= FIELD_OFFSET( FILE_NAME_INFORMATION, FileName);
3243 if( ulCopyLength > 0)
3246 pNameInfo->FileName[ 0] = L'\\';
3247 ulCopyLength -= sizeof( WCHAR);
3249 *Length -= sizeof( WCHAR);
3251 if( ulCopyLength >= AFSServerName.Length)
3254 RtlCopyMemory( &pNameInfo->FileName[ 1],
3255 AFSServerName.Buffer,
3256 AFSServerName.Length);
3258 ulCopyLength -= AFSServerName.Length;
3259 *Length -= AFSServerName.Length;
3261 if( ulCopyLength >= pCcb->FullFileName.Length)
3264 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3265 pCcb->FullFileName.Buffer,
3266 pCcb->FullFileName.Length);
3268 ulCopyLength -= pCcb->FullFileName.Length;
3269 *Length -= pCcb->FullFileName.Length;
3271 uniName.Length = (USHORT)pNameInfo->FileNameLength;
3272 uniName.MaximumLength = uniName.Length;
3273 uniName.Buffer = pNameInfo->FileName;
3278 RtlCopyMemory( &pNameInfo->FileName[ 1 + (AFSServerName.Length/sizeof( WCHAR))],
3279 pCcb->FullFileName.Buffer,
3282 *Length -= ulCopyLength;
3284 uniName.Length = (USHORT)(sizeof( WCHAR) + AFSServerName.Length + ulCopyLength);
3285 uniName.MaximumLength = uniName.Length;
3286 uniName.Buffer = pNameInfo->FileName;
3289 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3290 AFS_TRACE_LEVEL_VERBOSE,
3291 "AFSProcessPIOCtlQueryInfo (FileNameInformation) Returning %wZ\n",
3299 case FileInternalInformation:
3302 PFILE_INTERNAL_INFORMATION pInternalInfo = (PFILE_INTERNAL_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
3304 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3305 AFS_TRACE_LEVEL_VERBOSE,
3306 "AFSProcessPIOCtlQueryInfo (FileInternalInformation)\n");
3308 if( *Length >= sizeof( FILE_INTERNAL_INFORMATION))
3311 pInternalInfo->IndexNumber.HighPart = 0;
3313 pInternalInfo->IndexNumber.LowPart = 0;
3315 *Length -= sizeof( FILE_INTERNAL_INFORMATION);
3320 ntStatus = STATUS_BUFFER_TOO_SMALL;
3326 case FileAllInformation:
3328 ntStatus = STATUS_INVALID_PARAMETER;
3330 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3331 AFS_TRACE_LEVEL_WARNING,
3332 "AFSProcessPIOCtlQueryInfo (FileAllInformation) Not Implemented\n");
3337 case FileEaInformation:
3339 ntStatus = STATUS_INVALID_PARAMETER;
3341 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3342 AFS_TRACE_LEVEL_WARNING,
3343 "AFSProcessPIOCtlQueryInfo (FileEaInformation) Not Implemented\n");
3348 case FilePositionInformation:
3350 ntStatus = STATUS_INVALID_PARAMETER;
3352 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3353 AFS_TRACE_LEVEL_WARNING,
3354 "AFSProcessPIOCtlQueryInfo (FilePositionInformation) Not Implemented\n");
3359 case FileAlternateNameInformation:
3361 ntStatus = STATUS_INVALID_PARAMETER;
3363 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3364 AFS_TRACE_LEVEL_WARNING,
3365 "AFSProcessPIOCtlQueryInfo (FileAlternateNameInformation) Not Implemented\n");
3370 case FileNetworkOpenInformation:
3372 ntStatus = STATUS_INVALID_PARAMETER;
3374 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3375 AFS_TRACE_LEVEL_WARNING,
3376 "AFSProcessPIOCtlQueryInfo (FileNetworkOpenInformation) Not Implemented\n");
3381 case FileStreamInformation:
3383 ntStatus = STATUS_INVALID_PARAMETER;
3385 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3386 AFS_TRACE_LEVEL_WARNING,
3387 "AFSProcessPIOCtlQueryInfo (FileStreamInformation) Not Implemented\n");
3392 case FileAttributeTagInformation:
3394 ntStatus = STATUS_INVALID_PARAMETER;
3396 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3397 AFS_TRACE_LEVEL_WARNING,
3398 "AFSProcessPIOCtlQueryInfo (FileAttributeTagInformation) Not Implemented\n");
3403 case FileRemoteProtocolInformation:
3405 ntStatus = STATUS_INVALID_PARAMETER;
3407 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3408 AFS_TRACE_LEVEL_WARNING,
3409 "AFSProcessPIOCtlQueryInfo (FileRemoteProtocolInformation) Not Implemented\n");
3414 case FileNetworkPhysicalNameInformation:
3416 ntStatus = STATUS_INVALID_PARAMETER;
3418 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3419 AFS_TRACE_LEVEL_WARNING,
3420 "AFSProcessPIOCtlQueryInfo (FileNetworkPhysicalNameInformation) Not Implemented\n");
3427 ntStatus = STATUS_INVALID_PARAMETER;
3429 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3430 AFS_TRACE_LEVEL_WARNING,
3431 "AFSProcessPIOCtlQueryInfo Not handling request %08lX\n",
3432 ulFileInformationClass);
3439 AFSDbgLogMsg( AFS_SUBSYSTEM_PIOCTL_PROCESSING,
3440 AFS_TRACE_LEVEL_VERBOSE,
3441 "AFSProcessPIOCtlQueryInfo ntStatus %08lX\n",