reactos/drivers/filesystems/ntfs/finfo.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * COPYRIGHT:        See COPYING in the top level directory
  20  * PROJECT:          ReactOS kernel
  21  * FILE:             drivers/filesystem/ntfs/dirctl.c
  22  * PURPOSE:          NTFS filesystem driver
  23  * PROGRAMMERS:      Eric Kohl
  24  *                   Hervé Poussineau (hpoussin@reactos.org)
  25  */
  26
  27 /* INCLUDES *****************************************************************/
  28
  29 #include "ntfs.h"
  30
  31 #define NDEBUG
  32 #include <debug.h>
  33
  34 /* FUNCTIONS ****************************************************************/
  35
  36 /*
  37  * FUNCTION: Retrieve the standard file information
  38  */
  39 static
  40 NTSTATUS
  41 NtfsGetStandardInformation(PNTFS_FCB Fcb,
  42                            PDEVICE_OBJECT DeviceObject,
  43                            PFILE_STANDARD_INFORMATION StandardInfo,
  44                            PULONG BufferLength)
  45 {
  46     UNREFERENCED_PARAMETER(DeviceObject);
  47
  48     DPRINT1("NtfsGetStandardInformation(%p, %p, %p, %p)\n", Fcb, DeviceObject, StandardInfo, BufferLength);
  49
  50     if (*BufferLength < sizeof(FILE_STANDARD_INFORMATION))
  51         return STATUS_BUFFER_OVERFLOW;
  52
  53     /* PRECONDITION */
  54     ASSERT(StandardInfo != NULL);
  55     ASSERT(Fcb != NULL);
  56
  57     RtlZeroMemory(StandardInfo,
  58                   sizeof(FILE_STANDARD_INFORMATION));
  59
  60     StandardInfo->AllocationSize = Fcb->RFCB.AllocationSize;
  61     StandardInfo->EndOfFile = Fcb->RFCB.FileSize;
  62     StandardInfo->NumberOfLinks = Fcb->LinkCount;
  63     StandardInfo->DeletePending = FALSE;
  64     StandardInfo->Directory = NtfsFCBIsDirectory(Fcb);
  65
  66     *BufferLength -= sizeof(FILE_STANDARD_INFORMATION);
  67
  68     return STATUS_SUCCESS;
  69 }
  70
  71
  72 static
  73 NTSTATUS
  74 NtfsGetPositionInformation(PFILE_OBJECT FileObject,
  75                            PFILE_POSITION_INFORMATION PositionInfo,
  76                            PULONG BufferLength)
  77 {
  78     DPRINT1("NtfsGetPositionInformation(%p, %p, %p)\n", FileObject, PositionInfo, BufferLength);
  79
  80     if (*BufferLength < sizeof(FILE_POSITION_INFORMATION))
  81         return STATUS_BUFFER_OVERFLOW;
  82
  83     PositionInfo->CurrentByteOffset.QuadPart = FileObject->CurrentByteOffset.QuadPart;
  84
  85     DPRINT("Getting position %I64x\n",
  86            PositionInfo->CurrentByteOffset.QuadPart);
  87
  88     *BufferLength -= sizeof(FILE_POSITION_INFORMATION);
  89
  90     return STATUS_SUCCESS;
  91 }
  92
  93
  94 static
  95 NTSTATUS
  96 NtfsGetBasicInformation(PFILE_OBJECT FileObject,
  97                         PNTFS_FCB Fcb,
  98                         PDEVICE_OBJECT DeviceObject,
  99                         PFILE_BASIC_INFORMATION BasicInfo,
 100                         PULONG BufferLength)
 101 {
 102     PFILENAME_ATTRIBUTE FileName = &Fcb->Entry;
 103
 104     DPRINT1("NtfsGetBasicInformation(%p, %p, %p, %p, %p)\n", FileObject, Fcb, DeviceObject, BasicInfo, BufferLength);
 105
 106     if (*BufferLength < sizeof(FILE_BASIC_INFORMATION))
 107         return STATUS_BUFFER_OVERFLOW;
 108
 109     BasicInfo->CreationTime.QuadPart = FileName->CreationTime;
 110     BasicInfo->LastAccessTime.QuadPart = FileName->LastAccessTime;
 111     BasicInfo->LastWriteTime.QuadPart = FileName->LastWriteTime;
 112     BasicInfo->ChangeTime.QuadPart = FileName->ChangeTime;
 113
 114     NtfsFileFlagsToAttributes(FileName->FileAttributes, &BasicInfo->FileAttributes);
 115
 116     *BufferLength -= sizeof(FILE_BASIC_INFORMATION);
 117
 118     return STATUS_SUCCESS;
 119 }
 120
 121
 122 /*
 123  * FUNCTION: Retrieve the file name information
 124  */
 125 static
 126 NTSTATUS
 127 NtfsGetNameInformation(PFILE_OBJECT FileObject,
 128                        PNTFS_FCB Fcb,
 129                        PDEVICE_OBJECT DeviceObject,
 130                        PFILE_NAME_INFORMATION NameInfo,
 131                        PULONG BufferLength)
 132 {
 133     ULONG BytesToCopy;
 134
 135     UNREFERENCED_PARAMETER(FileObject);
 136     UNREFERENCED_PARAMETER(DeviceObject);
 137
 138     DPRINT1("NtfsGetNameInformation(%p, %p, %p, %p, %p)\n", FileObject, Fcb, DeviceObject, NameInfo, BufferLength);
 139
 140     ASSERT(NameInfo != NULL);
 141     ASSERT(Fcb != NULL);
 142
 143     /* If buffer can't hold at least the file name length, bail out */
 144     if (*BufferLength < (ULONG)FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]))
 145         return STATUS_BUFFER_OVERFLOW;
 146
 147     /* Save file name length, and as much file len, as buffer length allows */
 148     NameInfo->FileNameLength = wcslen(Fcb->PathName) * sizeof(WCHAR);
 149
 150     /* Calculate amount of bytes to copy not to overflow the buffer */
 151     BytesToCopy = min(NameInfo->FileNameLength,
 152                       *BufferLength - FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]));
 153
 154     /* Fill in the bytes */
 155     RtlCopyMemory(NameInfo->FileName, Fcb->PathName, BytesToCopy);
 156
 157     /* Check if we could write more but are not able to */
 158     if (*BufferLength < NameInfo->FileNameLength + (ULONG)FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]))
 159     {
 160         /* Return number of bytes written */
 161         *BufferLength -= FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]) + BytesToCopy;
 162         return STATUS_BUFFER_OVERFLOW;
 163     }
 164
 165     /* We filled up as many bytes, as needed */
 166     *BufferLength -= (FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]) + NameInfo->FileNameLength);
 167
 168     return STATUS_SUCCESS;
 169 }
 170
 171
 172 static
 173 NTSTATUS
 174 NtfsGetInternalInformation(PNTFS_FCB Fcb,
 175                            PFILE_INTERNAL_INFORMATION InternalInfo,
 176                            PULONG BufferLength)
 177 {
 178     DPRINT1("NtfsGetInternalInformation(%p, %p, %p)\n", Fcb, InternalInfo, BufferLength);
 179
 180     ASSERT(InternalInfo);
 181     ASSERT(Fcb);
 182
 183     if (*BufferLength < sizeof(FILE_INTERNAL_INFORMATION))
 184         return STATUS_BUFFER_OVERFLOW;
 185
 186     InternalInfo->IndexNumber.QuadPart = Fcb->MFTIndex;
 187
 188     *BufferLength -= sizeof(FILE_INTERNAL_INFORMATION);
 189
 190     return STATUS_SUCCESS;
 191 }
 192
 193 static
 194 NTSTATUS
 195 NtfsGetNetworkOpenInformation(PNTFS_FCB Fcb,
 196                               PDEVICE_EXTENSION DeviceExt,
 197                               PFILE_NETWORK_OPEN_INFORMATION NetworkInfo,
 198                               PULONG BufferLength)
 199 {
 200     PFILENAME_ATTRIBUTE FileName = &Fcb->Entry;
 201
 202     DPRINT1("NtfsGetNetworkOpenInformation(%p, %p, %p, %p)\n", Fcb, DeviceExt, NetworkInfo, BufferLength);
 203
 204     if (*BufferLength < sizeof(FILE_NETWORK_OPEN_INFORMATION))
 205         return(STATUS_BUFFER_OVERFLOW);
 206
 207     NetworkInfo->CreationTime.QuadPart = FileName->CreationTime;
 208     NetworkInfo->LastAccessTime.QuadPart = FileName->LastAccessTime;
 209     NetworkInfo->LastWriteTime.QuadPart = FileName->LastWriteTime;
 210     NetworkInfo->ChangeTime.QuadPart = FileName->ChangeTime;
 211
 212     NetworkInfo->EndOfFile.QuadPart = FileName->AllocatedSize;
 213     NetworkInfo->AllocationSize.QuadPart = ROUND_UP(FileName->AllocatedSize, DeviceExt->NtfsInfo.BytesPerCluster);
 214
 215     NtfsFileFlagsToAttributes(FileName->FileAttributes, &NetworkInfo->FileAttributes);
 216
 217     *BufferLength -= sizeof(FILE_NETWORK_OPEN_INFORMATION);
 218     return STATUS_SUCCESS;
 219 }
 220
 221 /*
 222  * FUNCTION: Retrieve the specified file information
 223  */
 224 NTSTATUS
 225 NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext)
 226 {
 227     FILE_INFORMATION_CLASS FileInformationClass;
 228     PIO_STACK_LOCATION Stack;
 229     PFILE_OBJECT FileObject;
 230     PNTFS_FCB Fcb;
 231     PVOID SystemBuffer;
 232     ULONG BufferLength;
 233     PIRP Irp;
 234     PDEVICE_OBJECT DeviceObject;
 235     NTSTATUS Status = STATUS_SUCCESS;
 236
 237     DPRINT1("NtfsQueryInformation(%p)\n", IrpContext);
 238
 239     Irp = IrpContext->Irp;
 240     Stack = IrpContext->Stack;
 241     DeviceObject = IrpContext->DeviceObject;
 242     FileInformationClass = Stack->Parameters.QueryFile.FileInformationClass;
 243     FileObject = IrpContext->FileObject;
 244     Fcb = FileObject->FsContext;
 245
 246     SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
 247     BufferLength = Stack->Parameters.QueryFile.Length;
 248
 249     switch (FileInformationClass)
 250     {
 251         case FileStandardInformation:
 252             Status = NtfsGetStandardInformation(Fcb,
 253                                                 DeviceObject,
 254                                                 SystemBuffer,
 255                                                 &BufferLength);
 256             break;
 257
 258         case FilePositionInformation:
 259             Status = NtfsGetPositionInformation(FileObject,
 260                                                 SystemBuffer,
 261                                                 &BufferLength);
 262             break;
 263
 264         case FileBasicInformation:
 265             Status = NtfsGetBasicInformation(FileObject,
 266                                              Fcb,
 267                                              DeviceObject,
 268                                              SystemBuffer,
 269                                              &BufferLength);
 270             break;
 271
 272         case FileNameInformation:
 273             Status = NtfsGetNameInformation(FileObject,
 274                                       Fcb,
 275                                       DeviceObject,
 276                                       SystemBuffer,
 277                                       &BufferLength);
 278             break;
 279
 280         case FileInternalInformation:
 281             Status = NtfsGetInternalInformation(Fcb,
 282                                                 SystemBuffer,
 283                                                 &BufferLength);
 284             break;
 285
 286         case FileNetworkOpenInformation:
 287             Status = NtfsGetNetworkOpenInformation(Fcb,
 288                                                    DeviceObject->DeviceExtension,
 289                                                    SystemBuffer,
 290                                                    &BufferLength);
 291             break;
 292
 293         case FileAlternateNameInformation:
 294         case FileAllInformation:
 295             DPRINT1("Unimplemented information class %u\n", FileInformationClass);
 296             Status = STATUS_NOT_IMPLEMENTED;
 297             break;
 298
 299         default:
 300             DPRINT1("Unimplemented information class %u\n", FileInformationClass);
 301             Status = STATUS_INVALID_PARAMETER;
 302     }
 303
 304     if (NT_SUCCESS(Status))
 305         Irp->IoStatus.Information =
 306             Stack->Parameters.QueryFile.Length - BufferLength;
 307     else
 308         Irp->IoStatus.Information = 0;
 309
 310     return Status;
 311 }
 312
 313 /* EOF */