Index: drivers/filesystems/CMakeLists.txt =================================================================== --- drivers/filesystems/CMakeLists.txt (revision 58300) +++ drivers/filesystems/CMakeLists.txt (working copy) @@ -8,3 +8,4 @@ add_subdirectory(mup) add_subdirectory(npfs) add_subdirectory(ntfs) +add_subdirectory(udfs) Index: drivers/filesystems/udfs/CMakeLists.txt =================================================================== --- drivers/filesystems/udfs/CMakeLists.txt (revision 0) +++ drivers/filesystems/udfs/CMakeLists.txt (working copy) @@ -0,0 +1,18 @@ + +include_directories(${REACTOS_SOURCE_DIR}/include/reactos/drivers) + +list(APPEND SOURCE + udfinit.c + fsctrl.c + misc.c + device.c + udfs.rc) + +add_library(udfs SHARED ${SOURCE}) + +set_module_type(udfs kernelmodedriver) +add_importlibs(udfs ntoskrnl hal) + +add_pch(udfs procs.h) + +add_cd_file(TARGET udfs DESTINATION reactos/system32/drivers NO_CAB FOR all) \ No newline at end of file Index: drivers/filesystems/udfs/device.c =================================================================== --- drivers/filesystems/udfs/device.c (revision 0) +++ drivers/filesystems/udfs/device.c (working copy) @@ -0,0 +1,76 @@ +#include"procs.h" + + + +NTSTATUS NTAPI + PerformDevIoCtrl + ( + IN PIRP_CONTEXT IrpContext, + IN ULONG IoCtrlCode, + IN PDEVICE_OBJECT DevObj, + OUT PVOID OutputBuffer, + IN ULONG OutBuffLen, + IN BOOLEAN InternDevCtrl, + IN BOOLEAN Override, + OUT PIO_STATUS_BLOCK IoStatusBlock + ) +{ + PIRP Irp; + KEVENT Event; + NTSTATUS Status; + PIO_STATUS_BLOCK StatusBlock; + PIO_STACK_LOCATION Stack; + + /* Is this a valid status block? */ + if (IoStatusBlock!=NULL){ + StatusBlock=IoStatusBlock; + } + + /* Initialize status block */ + StatusBlock->Status=0; + StatusBlock->Information=0; + + /* Initialize the event */ + KeInitializeEvent(&Event,NotificationEvent,FALSE); + + /* Set up the irp */ + Irp=IoBuildDeviceIoControlRequest + ( + IoCtrlCode, + DevObj, + NULL, + 0, + OutputBuffer, + OutBuffLen, + InternDevCtrl, + &Event, + StatusBlock + ); + + /* The returned irp is vaild? */ + if (Irp==NULL){ + /* Return if is not */ + return STATUS_INSUFFICIENT_RESOURCES; + } + + /* Is the override flag set ? */ + if (Override){ + /* Get a pointer to the next-lower driver's I/O stack location */ + Stack=IoGetNextIrpStackLocation(Irp); + /* Setting the flag */ + Stack->Flags |=SL_OVERRIDE_VERIFY_VOLUME; + } + + /* Send the irp */ + Status=IoCallDriver(DevObj,Irp); + + /* If the returned value is STATUS_PENDING, then we need to wait */ + if (Status==STATUS_PENDING){ + + /* Wait for the event to be signaled */ + KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL); + /* Setting the returned status */ + Status = StatusBlock->Status; + } + return Status; +} \ No newline at end of file Index: drivers/filesystems/udfs/ecma167.h =================================================================== --- drivers/filesystems/udfs/ecma167.h (revision 0) +++ drivers/filesystems/udfs/ecma167.h (working copy) @@ -0,0 +1,872 @@ + +/* + * ecma_167.h + * + * This file is based on ECMA-167 3rd edition (June 1997) + * http://www.ecma.ch + * + * Copyright (c) 2001-2002 Ben Fennema + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU Public License ("GPL"). + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + + +/* Character set specification (ECMA 167r3 1/7.2.1) */ +typedef struct _CHARSPEC{ + UINT8 CharSetType; + UINT8 CharSetInfo[63]; +}CHARSPEC; +typedef CHARSPEC *PCHARSPEC; + + +/* Character Set Type (ECMA 167r3 1/7.2.1.1) */ +#define CHARSPEC_TYPE_CS0 0x00 /* (1/7.2.2) */ +#define CHARSPEC_TYPE_CS1 0x01 /* (1/7.2.3) */ +#define CHARSPEC_TYPE_CS2 0x02 /* (1/7.2.4) */ +#define CHARSPEC_TYPE_CS3 0x03 /* (1/7.2.5) */ +#define CHARSPEC_TYPE_CS4 0x04 /* (1/7.2.6) */ +#define CHARSPEC_TYPE_CS5 0x05 /* (1/7.2.7) */ +#define CHARSPEC_TYPE_CS6 0x06 /* (1/7.2.8) */ +#define CHARSPEC_TYPE_CS7 0x07 /* (1/7.2.9) */ +#define CHARSPEC_TYPE_CS8 0x08 /* (1/7.2.10) */ + +typedef unsigned char DSTRING; + +/* Timestamp (ECMA 167r3 1/7.3) */ +typedef struct _TIMESTAMP { + USHORT TypeAndTimezone; + SHORT Year; + UINT8 Month; + UINT8 Day; + UINT8 Hour; + UINT8 Minute; + UINT8 Second; + UINT8 Centiseconds; + UINT8 HundredsOfMicroSeconds; + UINT8 Microseconds; +}TIMESTAMP; +typedef TIMESTAMP *PTIMESTAMP; + +/* Type and Time Zone (ECMA 167r3 1/7.3.1) */ +#define TIMESTAMP_TYPE_MASK 0xF000 +#define TIMESTAMP_TYPE_CUT 0x0000 +#define TIMESTAMP_TYPE_LOCAL 0x1000 +#define TIMESTAMP_TYPE_AGREEMENT 0x2000 +#define TIMESTAMP_TIMEZONE_MASK 0x0FFF + + +/* Entity identifier (ECMA 167r3 1/7.4) */ +typedef struct _REGID +{ + UINT8 Flags; + UINT8 Ident[23]; + UINT8 IdentSuffix[8]; +}REGID; +typedef REGID *PREGID; + +/* Flags (ECMA 167r3 1/7.4.1) */ +#define ENTITYID_FLAGS_DIRTY 0x00 +#define ENTITYID_FLAGS_PROTECTED 0x01 + +/* Volume Structure Descriptor (ECMA 167r3 2/9.1) */ +#define VSD_STD_ID_LEN 5 +typedef struct _VOLSTRUCTDESC +{ + UINT8 StructType; + UINT8 StdIdent[VSD_STD_ID_LEN]; + UINT8 StructVersion; + UINT8 StructData[2041]; +}VOLSTRUCTDESC; +typedef VOLSTRUCTDESC *PVOLSTRUCTDESC; + + +/* Standard Identifier (EMCA 167r2 2/9.1.2) */ +#define VSD_STD_ID_NSR02 "NSR02" /* (3/9.1) */ + +/* Standard Identifier (ECMA 167r3 2/9.1.2) */ +#define VSD_STD_ID_BEA01 "BEA01" /* (2/9.2) */ +#define VSD_STD_ID_BOOT2 "BOOT2" /* (2/9.4) */ +#define VSD_STD_ID_CD001 "CD001" /* (ECMA-119) */ +#define VSD_STD_ID_CDW02 "CDW02" /* (ECMA-168) */ +#define VSD_STD_ID_NSR03 "NSR03" /* (3/9.1) */ +#define VSD_STD_ID_TEA01 "TEA01" /* (2/9.3) */ + + +/* Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) */ +typedef struct _BEGINNING_EXTENDED_AREA_DESC +{ + UINT8 StructType; + UINT8 StdIdent[VSD_STD_ID_LEN]; + UINT8 StructVersion; + UINT8 StructData[2041]; +} BEGINNING_EXTENDED_AREA_DESC; +typedef BEGINNING_EXTENDED_AREA_DESC * PBEGINNING_EXTENDED_AREA_DESC; + +/* Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) */ +typedef struct _TERMINATING_EXTENDED_AREA_DESC +{ + UINT8 StructType; + UINT8 StdIdent[VSD_STD_ID_LEN]; + UINT8 StructVersion; + UINT8 StructData[2041]; +}TERMINATING_EXTENDED_AREA_DESC; +typedef TERMINATING_EXTENDED_AREA_DESC *PTERMINATING_EXTENDED_AREA_DESC; + +/* Boot Descriptor (ECMA 167r3 2/9.4) */ +typedef struct _BOOT_DESC +{ + UINT8 StructType; + UINT8 StdIdent[VSD_STD_ID_LEN]; + UINT8 StructVersion; + UINT8 Reserved1; + REGID ArchType; + REGID BootIdent; + UINT32 BootExtLocation; + UINT32 BootExtLength; + UINT64 LoadAddress; + UINT64 StartAddress; + TIMESTAMP DescCreationDateAndTime; + USHORT Flags; + UINT8 Reserved2[32]; + UINT8 BootUse[1906]; +}BOOT_DESC; +typedef BOOT_DESC *PBOOTD_ESC; + +/* Flags (ECMA 167r3 2/9.4.12) */ +#define BOOT_FLAGS_ERASE 0x01 + +/* Extent Descriptor (ECMA 167r3 3/7.1) */ +typedef struct _EXTENDED_AD +{ + UINT32 ExtLength; + UINT32 ExtLocation; +}EXTENDED_AD; +typedef EXTENDED_AD *PEXTENDED_AD; + + +/* Descriptor Tag (ECMA 167r3 3/7.2) */ +typedef struct _TAG +{ + USHORT TagIdent; + USHORT DescVersion; + UINT8 TagChecksum; + UINT8 Reserved; + USHORT TagSerialNum; + USHORT DescCRC; + USHORT DescCRCLength; + UINT32 TagLocation; +}TAG; +typedef TAG *PTAG; + +/* Tag Identifier (ECMA 167r3 3/7.2.1) */ +#define TAG_IDENT_PVD 0x0001 +#define TAG_IDENT_AVDP 0x0002 +#define TAG_IDENT_VDP 0x0003 +#define TAG_IDENT_IUVD 0x0004 +#define TAG_IDENT_PD 0x0005 +#define TAG_IDENT_LVD 0x0006 +#define TAG_IDENT_USD 0x0007 +#define TAG_IDENT_TD 0x0008 +#define TAG_IDENT_LVID 0x0009 + +/* NSR Descriptor (ECMA 167r3 3/9.1) */ +typedef struct _NSR_DESC +{ + UINT8 StructType; + UINT8 StdIdent[VSD_STD_ID_LEN]; + UINT8 StructVersion; + UINT8 Reserved; + UINT8 StructData[2040]; +}NSR_DESC; +typedef NSR_DESC *PNSR_DESC; + + +/* Primary Volume Descriptor (ECMA 167r3 3/10.1) */ +typedef struct _PRIMARY_VOL_DESC +{ + TAG DescTag; + UINT32 VolDescSeqNum; + UINT32 PrimaryVolDescNum; + DSTRING VolIdent[32]; + USHORT VolSeqNum; + USHORT MaxVolSeqNum; + USHORT InterchangeLvl; + USHORT MaxInterchangeLvl; + UINT32 CharSetList; + UINT32 MaxCharSetList; + DSTRING VolSetIdent[128]; + CHARSPEC DescCharSet; + CHARSPEC ExplanatoryCharSet; + EXTENDED_AD VolAbstract; + EXTENDED_AD VolCopyright; + REGID AppIdent; + TIMESTAMP RecordingDateAndTime; + REGID ImpIdent; + UINT8 ImpUse[64]; + UINT32 PredecessorVolDescSeqLocation; + USHORT Flags; + UINT8 Reserved[22]; +}PRIMARY_VOL_DESC; +typedef PRIMARY_VOL_DESC *PPRIMARY_VOL_DESC; + +/* Flags (ECMA 167r3 3/10.1.21) */ +#define PVD_FLAGS_VSID_COMMON 0x0001 + + +/* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */ +typedef struct _ANCHOR_VOL_DESC_PTR +{ + TAG DescTag; + EXTENDED_AD MainVolDescSeqExt; + EXTENDED_AD ReserveVolDescSeqExt; + UINT8 Reserved[480]; +}ANCHOR_VOL_DESC_PTR; +typedef ANCHOR_VOL_DESC_PTR *PANCHOR_VOL_DESC_PTR; + +/* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */ +typedef struct _VOL_DESC_PTR +{ + TAG DescTag; + UINT32 VolDescSeqNum; + EXTENDED_AD NextVolDescSeqExt; + UINT8 Reserved[484]; +} VOL_DESC_PTR; +typedef VOL_DESC_PTR *PVOL_DESC_PTR; + +/* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */ +typedef struct _IMP_USE_VOL_DESC +{ + TAG DescTag; + UINT32 VolDescSeqNum; + REGID ImpIdent; + UINT8 ImpUse[460]; +} IMP_USE_VOL_DESC; +typedef IMP_USE_VOL_DESC *PIMP_USE_VOL_DESC; + +/* Partition Descriptor (ECMA 167r3 3/10.5) */ +typedef struct _PARTITION_DESC +{ + TAG DescTag; + UINT32 VolDescSeqNum; + USHORT PartitionFlags; + USHORT PartitionNumber; + REGID PartitionContents; + UINT8 PartitionContentsUse[128]; + UINT32 AccessType; + UINT32 PartitionStartingLocation; + UINT32 PartitionLength; + REGID ImpIdent; + UINT8 ImpUse[128]; + UINT8 Reserved[156]; +}PARTITION_DESC ; +typedef PARTITION_DESC *PPARTITION_DESCP; + +/* Partition Flags (ECMA 167r3 3/10.5.3) */ +#define PD_PARTITION_FLAGS_ALLOC 0x0001 + +/* Partition Contents (ECMA 167r2 3/10.5.3) */ +#define PD_PARTITION_CONTENTS_NSR02 "+NSR02" + +/* Partition Contents (ECMA 167r3 3/10.5.5) */ +#define PD_PARTITION_CONTENTS_FDC01 "+FDC01" +#define PD_PARTITION_CONTENTS_CD001 "+CD001" +#define PD_PARTITION_CONTENTS_CDW02 "+CDW02" +#define PD_PARTITION_CONTENTS_NSR03 "+NSR03" + +/* Access Type (ECMA 167r3 3/10.5.7) */ +#define PD_ACCESS_TYPE_NONE 0x00000000 +#define PD_ACCESS_TYPE_READ_ONLY 0x00000001 +#define PD_ACCESS_TYPE_WRITE_ONCE 0x00000002 +#define PD_ACCESS_TYPE_REWRITABLE 0x00000003 +#define PD_ACCESS_TYPE_OVERWRITABLE 0x00000004 + +/* Logical Volume Descriptor (ECMA 167r3 3/10.6) */ +typedef struct _LOGICAL_VOL_DESC +{ + TAG DescTag; + UINT32 VolDescSeqNum; + CHARSPEC DescCharSet; + DSTRING LogicalVolIdent[128]; + UINT32 LogicalBlockSize; + REGID DomainIdent; + UINT8 LogicalVolContentsUse[16]; + UINT32 MapTableLength; + UINT32 NumPartitionMaps; + REGID ImpIdent; + UINT8 ImpUse[128]; + EXTENDED_AD IntegritySeqExt; + UINT8 PartitionMaps[0]; +}LOGICAL_VOL_DESC; +typedef LOGICAL_VOL_DESC *PLOGICAL_VOL_DESC; + +/* Generic Partition Map (ECMA 167r3 3/10.7.1) */ +typedef struct _GENERIC_PARTITION_MAP +{ + UINT8 PartitionMapType; + UINT8 PartitionMapLength; + UINT8 PartitionMapping[0]; +}GENERIC_PARTITION_MAP; +typedef GENERIC_PARTITION_MAP *PGENERIC_PARTITION_MAP; + +/* Partition Map Type (ECMA 167r3 3/10.7.1.1) */ +#define GP_PARTITION_MAP_TYPE_UNDEF 0x00 +#define GP_PARTIITON_MAP_TYPE_1 0x01 +#define GP_PARTITION_MAP_TYPE_2 0x02 + +/* Type 1 Partition Map (ECMA 167r3 3/10.7.2) */ +typedef struct _GENERIC_PARTITION_MAP1 +{ + UINT8 PartitionMapType; + UINT8 PartitionMapLength; + USHORT VolSeqNum; + USHORT PartitionNum; +} GENERIC_PARTITION_MAP1; +typedef GENERIC_PARTITION_MAP1 *PGENERIC_PARTITION_MAP1; + +/* Type 2 Partition Map (ECMA 167r3 3/10.7.3) */ +typedef struct _GENERIC_PARTITION_MA2 +{ + UINT8 PartitionMapType; + UINT8 PartitionMapLength; + UINT8 PartitionIdent[62]; +}GENERIC_PARTITION_MA2; +typedef GENERIC_PARTITION_MA2 *PGENERIC_PARTITION_MA2; + +/* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */ +typedef struct _UNALLOC_SPACE_DESC +{ + TAG DescTag; + UINT32 VolDescSeqNum; + UINT32 NumAllocDescs; + EXTENDED_AD AllocDescs[0]; +}UNALLOC_SPACE_DESC; +typedef UNALLOC_SPACE_DESC *PUNALLOC_SPACE_DESC; + +/* Terminating Descriptor (ECMA 167r3 3/10.9) */ +typedef struct _TERMINATING_DESC +{ + TAG DescTag; + UINT8 Reserved[496]; +}TERMINATING_DESC; +typedef TERMINATING_DESC *PTERMINATING_DESC; + +/* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */ +typedef struct _LOGICAL_VOL_INTEGRITY_DESC +{ + TAG DescTag; + TIMESTAMP RecordingDateAndTime; + UINT32 IntegrityType; + EXTENDED_AD NextIntegrityExt; + UINT8 LogicalVolContentsUse[32]; + UINT32 NumOfPartitions; + UINT32 LengthOfImpUse; + UINT32 *FreeSpaceTable; + UINT32 *SizeTable; + UINT8 *ImpUse; +}LOGICAL_VOL_INTEGRITY_DESC; +typedef LOGICAL_VOL_INTEGRITY_DESC *PLOGICAL_VOL_INTEGRITY_DESC; + +/* Integrity Type (ECMA 167r3 3/10.10.3) */ +#define LVID_INTEGRITY_TYPE_OPEN 0x00000000 +#define LVID_INTEGRITY_TYPE_CLOSE 0x00000001 + +/* Recorded Address (ECMA 167r3 4/7.1) */ +typedef struct _LB_ADDR +{ + UINT32 LogicalBlockNum; + USHORT PartitionReferenceNum; +}LB_ADDR; +typedef LB_ADDR *PLB_ADDR; + +/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */ +typedef struct _SHORT_AD +{ + UINT32 ExtLength; + UINT32 ExtPosition; +} SHORT_AD; +typedef SHORT_AD *PSHORT_AD; + +/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */ +typedef struct _LONG_AD +{ + UINT32 ExtLength; + LB_ADDR ExtLocation; + UINT8 ImpUse[6]; +} LONG_AD; +typedef LONG_AD *PLONGAD; + +/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */ +typedef struct _EXT_AD +{ + UINT32 ExtLength; + UINT32 RecordedLength; + UINT32 InformationLength; + LB_ADDR ExtLocation; +} EXT_AD; +typedef EXT_AD *PEXT_AD; + +/* Descriptor Tag (ECMA 167r3 4/7.2 - See 3/7.2) */ + +/* Tag Identifier (ECMA 167r3 4/7.2.1) */ +#define TAG_IDENT_FSD 0x0100 +#define TAG_IDENT_FID 0x0101 +#define TAG_IDENT_AED 0x0102 +#define TAG_IDENT_IE 0x0103 +#define TAG_IDENT_TE 0x0104 +#define TAG_IDENT_FE 0x0105 +#define TAG_IDENT_EAHD 0x0106 +#define TAG_IDENT_USE 0x0107 +#define TAG_IDENT_SBD 0x0108 +#define TAG_IDENT_PIE 0x0109 +#define TAG_IDENT_EFE 0x010A + +/* File Set Descriptor (ECMA 167r3 4/14.1) */ +typedef struct _FILE_SET_DESC +{ + TAG DescTag; + TIMESTAMP RecordingDateAndTime; + USHORT InterchangeLvl; + USHORT MaxInterchangeLvl; + UINT32 CharSetList; + UINT32 MaxCharSetList; + UINT32 FileSetNum; + UINT32 FileSetDescNum; + CHARSPEC LogicalVolIdentCharSet; + DSTRING LogicalVolIdent[128]; + CHARSPEC FileSetCharSet; + DSTRING FileSetIdent[32]; + DSTRING CopyrightFileIdent[32]; + DSTRING AbstractFileIdent[32]; + LONG_AD RootDirectoryICB; + REGID DomainIdent; + LONG_AD NextExt; + LONG_AD StreamDirectoryICB; + UINT8 Reserved[32]; +}FILE_SET_DESC; +typedef FILE_SET_DESC *PFILE_SET_DESC; + +/* Partition Header Descriptor (ECMA 167r3 4/14.3) */ +typedef struct _PARTITION_HEADER_DESC +{ + SHORT_AD UnallocSpaceTable; + SHORT_AD UnallocSpaceBitmap; + SHORT_AD PartitionIntegrityTable; + SHORT_AD FreedSpaceTable; + SHORT_AD FreedSpaceBitmap; + UINT8 Reserved[88]; +} PARTITION_HEADER_DESC; +typedef PARTITION_HEADER_DESC *PPARTITION_HEADER_DESC; + +/* File Identifier Descriptor (ECMA 167r3 4/14.4) */ +typedef struct _FILE_IDENT_DESC +{ + TAG DescTag; + USHORT FileVersionNum; + UINT8 FileCharacteristics; + UINT8 LengthFileIdent; + LONG_AD Icb; + USHORT LengthOfImpUse; + UINT8 *ImpUse; + UINT8 *FileIdent; + UINT8 *Padding; +}FILE_IDENT_DESC; +typedef FILE_IDENT_DESC *PFILE_IDENT_DESC; + + +/* File Characteristics (ECMA 167r3 4/14.4.3) */ +#define FID_FILE_CHAR_HIDDEN 0x01 +#define FID_FILE_CHAR_DIRECTORY 0x02 +#define FID_FILE_CHAR_DELETED 0x04 +#define FID_FILE_CHAR_PARENT 0x08 +#define FID_FILE_CHAR_METADATA 0x10 + +/* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */ +typedef struct _ALLOC_EXT_DESC +{ + TAG DescTag; + UINT32 PreviousAllocExtLocation; + UINT32 LengthAllocDescs; +}ALLOC_EXT_DESC ; +typedef ALLOC_EXT_DESC *PALLOC_EXT_DESC; + +/* ICB Tag (ECMA 167r3 4/14.6) */ +typedef struct _ICBTAG +{ + UINT32 PriorRecordedNumDirectEntries; + USHORT StrategyType; + USHORT StrategyParameter; + USHORT NumEntries; + UINT8 Reserved; + UINT8 FileType; + LB_ADDR ParentICBLocation; + USHORT Flags; +}ICBTAG; +typedef ICBTAG *PICBTAG; + +/* Strategy Type (ECMA 167r3 4/14.6.2) */ +#define ICBTAG_STRATEGY_TYPE_UNDEF 0x0000 +#define ICBTAG_STRATEGY_TYPE_1 0x0001 +#define ICBTAG_STRATEGY_TYPE_2 0x0002 +#define ICBTAG_STRATEGY_TYPE_3 0x0003 +#define ICBTAG_STRATEGY_TYPE_4 0x0004 + +/* File Type (ECMA 167r3 4/14.6.6) */ +#define ICBTAG_FILE_TYPE_UNDEF 0x00 +#define ICBTAG_FILE_TYPE_USE 0x01 +#define ICBTAG_FILE_TYPE_PIE 0x02 +#define ICBTAG_FILE_TYPE_IE 0x03 +#define ICBTAG_FILE_TYPE_DIRECTORY 0x04 +#define ICBTAG_FILE_TYPE_REGULAR 0x05 +#define ICBTAG_FILE_TYPE_BLOCK 0x06 +#define ICBTAG_FILE_TYPE_CHAR 0x07 +#define ICBTAG_FILE_TYPE_EA 0x08 +#define ICBTAG_FILE_TYPE_FIFO 0x09 +#define ICBTAG_FILE_TYPE_SOCKET 0x0A +#define ICBTAG_FILE_TYPE_TE 0x0B +#define ICBTAG_FILE_TYPE_SYMLINK 0x0C +#define ICBTAG_FILE_TYPE_STREAMDIR 0x0D + +/* Flags (ECMA 167r3 4/14.6.8) */ +#define ICBTAG_FLAG_AD_MASK 0x0007 +#define ICBTAG_FLAG_AD_SHORT 0x0000 +#define ICBTAG_FLAG_AD_LONG 0x0001 +#define ICBTAG_FLAG_AD_EXTENDED 0x0002 +#define ICBTAG_FLAG_AD_IN_ICB 0x0003 +#define ICBTAG_FLAG_SORTED 0x0008 +#define ICBTAG_FLAG_NONRELOCATABLE 0x0010 +#define ICBTAG_FLAG_ARCHIVE 0x0020 +#define ICBTAG_FLAG_SETUID 0x0040 +#define ICBTAG_FLAG_SETGID 0x0080 +#define ICBTAG_FLAG_STICKY 0x0100 +#define ICBTAG_FLAG_CONTIGUOUS 0x0200 +#define ICBTAG_FLAG_SYSTEM 0x0400 +#define ICBTAG_FLAG_TRANSFORMED 0x0800 +#define ICBTAG_FLAG_MULTIVERSIONS 0x1000 +#define ICBTAG_FLAG_STREAM 0x2000 + +/* Indirect Entry (ECMA 167r3 4/14.7) */ +typedef struct _INDIRECT_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; + LONG_AD IndirectICB; +}INDIRECT_ENTRY; +typedef INDIRECT_ENTRY *PINDIRECT_ENTRY; + +/* Terminal Entry (ECMA 167r3 4/14.8) */ +typedef struct _TERMINAL_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; +}TERMINAL_ENTRY; +typedef TERMINAL_ENTRY *PTERMINAL_ENTRY; +/* File Entry (ECMA 167r3 4/14.9) */ +typedef struct _FILE_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; + UINT32 Uid; + UINT32 Gid; + UINT32 Permissions; + USHORT FileLinkCount; + UINT8 RecordFormat; + UINT8 RecordDisplayAttr; + UINT32 RecordLength; + ULONGLONG InformationLength; + ULONGLONG LogicalBlocksRecorded; + TIMESTAMP AccessTime; + TIMESTAMP ModificationTime; + TIMESTAMP AttrTime; + UINT32 Checkpoint; + LONG_AD ExtendedAttrICB; + REGID ImpIdent; + ULONGLONG UniqueID; + UINT32 LengthExtendedAttr; + UINT32 LengthAllocDescs; + UINT8 *ExtendedAttr; + UINT8 *AllocDescs; +}FILE_ENTRY; +typedef FILE_ENTRY *PFILE_ENTRY; + +/* Permissions (ECMA 167r3 4/14.9.5) */ +#define FE_PERM_O_EXEC 0x00000001U +#define FE_PERM_O_WRITE 0x00000002U +#define FE_PERM_O_READ 0x00000004U +#define FE_PERM_O_CHATTR 0x00000008U +#define FE_PERM_O_DELETE 0x00000010U +#define FE_PERM_G_EXEC 0x00000020U +#define FE_PERM_G_WRITE 0x00000040U +#define FE_PERM_G_READ 0x00000080U +#define FE_PERM_G_CHATTR 0x00000100U +#define FE_PERM_G_DELETE 0x00000200U +#define FE_PERM_U_EXEC 0x00000400U +#define FE_PERM_U_WRITE 0x00000800U +#define FE_PERM_U_READ 0x00001000U +#define FE_PERM_U_CHATTR 0x00002000U +#define FE_PERM_U_DELETE 0x00004000U + +/* Record Format (ECMA 167r3 4/14.9.7) */ +#define FE_RECORD_FMT_UNDEF 0x00 +#define FE_RECORD_FMT_FIXED_PAD 0x01 +#define FE_RECORD_FMT_FIXED 0x02 +#define FE_RECORD_FMT_VARIABLE8 0x03 +#define FE_RECORD_FMT_VARIABLE16 0x04 +#define FE_RECORD_FMT_VARIABLE16_MSB 0x05 +#define FE_RECORD_FMT_VARIABLE32 0x06 +#define FE_RECORD_FMT_PRINT 0x07 +#define FE_RECORD_FMT_LF 0x08 +#define FE_RECORD_FMT_CR 0x09 +#define FE_RECORD_FMT_CRLF 0x0A +#define FE_RECORD_FMT_LFCR 0x0B + +/* Record Display Attributes (ECMA 167r3 4/14.9.8) */ +#define FE_RECORD_DISPLAY_ATTR_UNDEF 0x00 +#define FE_RECORD_DISPLAY_ATTR_1 0x01 +#define FE_RECORD_DISPLAY_ATTR_2 0x02 +#define FE_RECORD_DISPLAY_ATTR_3 0x03 + +/* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */ +typedef struct _EXTENDED_ATTR_HEADER_DESC +{ + TAG DescTag; + UINT32 ImpAttrLocation; + UINT32 AppAttrLocation; +}EXTENDED_ATTR_HEADER_DESC; +typedef EXTENDED_ATTR_HEADER_DESC *PEXTENDED_ATTR_HEADER_DESC; + +/* Generic Format (ECMA 167r3 4/14.10.2) */ +typedef struct _GENERIC_FORMAT +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT8 AttrData[0]; +}GENERIC_FORMAT; +typedef GENERIC_FORMAT *PGENERIC_FORMAT; + +/* Character Set Information (ECMA 167r3 4/14.10.3) */ +typedef struct _CHAR_SET_INFO +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Eeserved[3]; + UINT32 AttrLength; + UINT32 EscapeSeqLength; + UINT8 CharSetType; + UINT8 EscapeSeq[0]; +}CHAR_SET_INFO; +typedef CHAR_SET_INFO *PCHAR_SET_INFO; + +/* Alternate Permissions (ECMA 167r3 4/14.10.4) */ +typedef struct _ALT_PERMPS +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + USHORT OwnerIdent; + USHORT GroupIdent; + USHORT Permission; +} ALT_PERMPS; +typedef ALT_PERMPS *PALT_PERMPS; +/* File Times Extended Attribute (ECMA 167r3 4/14.10.5) */ +typedef struct _FILE_TIMES_EXT_ATTR +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT32 DataLength; + UINT32 FileTimeExistence; + UINT8 FileTimes; +}FILE_TIMES_EXT_ATTR; +typedef FILE_TIMES_EXT_ATTR *PFILE_TIMES_EXT_ATTR; + +/* FileTimeExistence (ECMA 167r3 4/14.10.5.6) */ +#define FTE_CREATION 0x00000001 +#define FTE_DELETION 0x00000004 +#define FTE_EFFECTIVE 0x00000008 +#define FTE_BACKUP 0x00000002 + +/* Information Times Extended Attribute (ECMA 167r3 4/14.10.6) */ +typedef struct _INFO_TIMES_EXT_ATTR +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT32 DataLength; + UINT32 InfoTimeExistence; + UINT8 InfoTimes[0]; +}INFO_TIMES_EXT_ATTR; +typedef INFO_TIMES_EXT_ATTR *PINFO_TIMES_EXT_ATTR; + +/* Device Specification (ECMA 167r3 4/14.10.7) */ +typedef struct _DEVICE_SPEC +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT32 ImpUseLength; + UINT32 MajorDeviceIdent; + UINT32 MinorDeviceIdent; + UINT8 ImpUse[0]; +} DEVICE_SPEC; +typedef DEVICE_SPEC *PDEVICE_SPEC; + +/* Implementation Use Extended Attr (ECMA 167r3 4/14.10.8) */ +typedef struct _IMP_USE_EXT_ATTR +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT32 ImpUseLength; + REGID ImpIdent; + UINT8 ImpUse[0]; +}IMP_USE_EXT_ATTR; +typedef IMP_USE_EXT_ATTR *PIMP_USE_EXT_ATTR; + +/* Application Use Extended Attribute (ECMA 167r3 4/14.10.9) */ +typedef struct _APP_USE_EXT_ATTR +{ + UINT32 AttrType; + UINT8 AttrSubtype; + UINT8 Reserved[3]; + UINT32 AttrLength; + UINT32 AppUseLength; + REGID AppIdent; + UINT8 AppUse[0]; +}APP_USE_EXT_ATTR; +typedef APP_USE_EXT_ATTR *PAPP_USE_EXT_ATTR; + +#define EXTATTR_CHAR_SET 1 +#define EXTATTR_ALT_PERMS 3 +#define EXTATTR_FILE_TIMES 5 +#define EXTATTR_INFO_TIMES 6 +#define EXTATTR_DEV_SPEC 12 +#define EXTATTR_IMP_USE 2048 +#define EXTATTR_APP_USE 65536 + + +/* Unallocated Space Entry (ECMA 167r3 4/14.11) */ +typedef struct _UNALLOC_SPACE_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; + UINT32 LengthAllocDescs; + UINT8 AllocDescs[0]; +}UNALLOC_SPACE_ENTRY; +typedef UNALLOC_SPACE_ENTRY *PUNALLOC_SPACE_ENTRY; + +/* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */ +typedef struct _SPACE_BITMAP_DESC +{ + TAG DescTag; + UINT32 NumOfBits; + UINT32 NumOfBytes; + UINT8 Bitmap[0]; +}SPACE_BITMAP_DESC; +typedef SPACE_BITMAP_DESC *PSPACE_BITMAP_DESC; + +/* Partition Integrity Entry (ECMA 167r3 4/14.13) */ +typedef struct _PARTITION_INTEGRITY_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; + TIMESTAMP RecordingDateAndTime; + UINT8 IntegrityType; + UINT8 Reserved[175]; + REGID ImpIdent; + UINT8 ImpUse[256]; +}PARTITION_INTEGRITY_ENTRY; +typedef PARTITION_INTEGRITY_ENTRY *PPARTITION_INTEGRITY_ENTRY; + +/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */ + +/* Extent Length (ECMA 167r3 4/14.14.1.1) */ +#define EXT_RECORDED_ALLOCATED 0x00000000 +#define EXT_NOT_RECORDED_ALLOCATED 0x40000000 +#define EXT_NOT_RECORDED_NOT_ALLOCATED 0x80000000 +#define EXT_NEXT_EXTENT_ALLOCDECS 0xC0000000 + +/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */ + +/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */ + +/* Logical Volume Header Descriptor (ECMA 167r3 4/14.15) */ +typedef struct _LOGICAL_VOL_HEADER_DESC +{ + ULONGLONG UniqueID; + UINT8 Reserved[24]; +}LOGICAL_VOL_HEADER_DESC; +typedef LOGICAL_VOL_HEADER_DESC *PLOGICAL_VOL_HEADER_DESC; + +/* Path Component (ECMA 167r3 4/14.16.1) */ +typedef struct _PATH_COMPONENT +{ + UINT8 ComponentType; + UINT8 LengthComponentIdent; + USHORT ComponentFileVersionNum; + DSTRING ComponentIdent[0]; +}PATH_COMPONENT; +typedef PATH_COMPONENT *PPATH_COMPONENT; +/* File Entry (ECMA 167r3 4/14.17) */ +typedef struct _EXTENDED_FILE_ENTRY +{ + TAG DescTag; + ICBTAG IcbTag; + UINT32 Uid; + UINT32 Gid; + UINT32 Permissions; + USHORT FileLinkCount; + UINT8 RecordFormat; + UINT8 EecordDisplayAttr; + UINT32 EecordLength; + ULONGLONG InformationLength; + ULONGLONG ObjectSize; + ULONGLONG LogicalBlocksRecorded; + TIMESTAMP AccessTime; + TIMESTAMP ModificationTime; + TIMESTAMP CreateTime; + TIMESTAMP AttrTime; + UINT32 Checkpoint; + UINT32 Reserved; + LONG_AD ExtendedAttrICB; + LONG_AD StreamDirectoryICB; + REGID ImpIdent; + ULONGLONG UniqueID; + UINT32 LengthExtendedAttr; + UINT32 LengthAllocDescs; + UINT8 *ExtendedAttr; + UINT8 *AllocDescs; +} EXTENDED_FILE_ENTRY; +typedef EXTENDED_FILE_ENTRY *PEXTENDED_FILE_ENTRY; + + + Index: drivers/filesystems/udfs/fsctrl.c =================================================================== --- drivers/filesystems/udfs/fsctrl.c (revision 0) +++ drivers/filesystems/udfs/fsctrl.c (working copy) @@ -0,0 +1,113 @@ +#include "procs.h" + + + +BOOLEAN Disable=FALSE; + +NTSTATUS NTAPI + FsFileSysControl( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ) +{ + NTSTATUS Status; + PIO_STACK_LOCATION IrpStackLocation; + /*Getting parameters*/ + IrpStackLocation=IoGetCurrentIrpStackLocation(Irp); + + /*Make sure that we are not at IRQL > APC_LEVEL*/ + PAGED_CODE(); + + /*Dispaching...*/ + switch (IrpStackLocation->MinorFunction) + { + case IRP_MN_USER_FS_REQUEST: + Status=UserFsctl(IrpContext,Irp); + break; + case IRP_MN_MOUNT_VOLUME: + Status=MountVolume(IrpContext,Irp); + break; + case IRP_MN_VERIFY_VOLUME : + Status=VerifyVolume(IrpContext,Irp); + break; + default: + break; + CompleteRequest(IrpContext,Irp,STATUS_INVALID_DEVICE_REQUEST); + Status=STATUS_INVALID_DEVICE_REQUEST; + } + return Status; +} + +/************************************************************************************/ + +NTSTATUS NTAPI + MountVolume ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ) +{ + + + PVPB Vpb; + NTSTATUS Status; + ULONG InputBuffer=0; + BOOLEAN Wait=TRUE; + ULONG MediaChangeCount; + IO_STATUS_BLOCK IoStatusBlock; + + /*Getting parameters*/ + PIO_STACK_LOCATION IrpStackLocation = IoGetCurrentIrpStackLocation(Irp); + PDEVICE_OBJECT TargDevObj = IrpStackLocation->Parameters.MountVolume.DeviceObject; + Vpb = IrpStackLocation->Parameters.MountVolume.Vpb; + /* Setting the device object */ + IrpContext->RealDevice=Vpb->RealDevice; + + /* Is our fsd disable? */ + if (Disable){ + /* Abord */ + CompleteRequest(IrpContext,Irp,STATUS_UNRECOGNIZED_VOLUME); + return STATUS_UNRECOGNIZED_VOLUME; + } + + /*Getting MediaChangeCount wich is used only by removable media*/ + Status=PerformDevIoCtrl + ( + IrpContext, + IOCTL_CDROM_CHECK_VERIFY, + TargDevObj, + &MediaChangeCount, + sizeof(ULONG), + FALSE, + TRUE, + &IoStatusBlock + ); + + /*Check if the operation was succefull*/ + if (!NT_SUCCESS(Status)){ + CompleteRequest(IrpContext,Irp,Status); + return Status; + } + return STATUS_NOT_IMPLEMENTED; +} +/************************************************************************************/ + +NTSTATUS NTAPI + UserFsctl ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ) +{ + return STATUS_NOT_IMPLEMENTED; +} + + +/************************************************************************************/ +NTSTATUS NTAPI + VerifyVolume ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ) +{ + return STATUS_NOT_IMPLEMENTED; +} +/************************************************************************************/ Index: drivers/filesystems/udfs/misc.c =================================================================== --- drivers/filesystems/udfs/misc.c (revision 0) +++ drivers/filesystems/udfs/misc.c (working copy) @@ -0,0 +1,132 @@ +#include "procs.h" + +/************************************************************************************/ +NTSTATUS NTAPI + UdfDispatch + ( + IN PDEVICE_OBJECT DeviceObject, + IN PIRP Irp + ) +{ + NTSTATUS Status; + PIRP_CONTEXT IrpContext=NULL; + BOOLEAN Wait; + + /*Ensure that the UdfDispacth cannot be suspended*/ + FsRtlEnterFileSystem(); + + /*Set the wait flag.*/ + if (IoGetCurrentIrpStackLocation(Irp)->FileObject==NULL){ + Wait=TRUE; + }else{ + Wait=IoIsOperationSynchronous(Irp); + } + /*Creating irp context. */ + IrpContext=CreateIrpContext(Irp,Wait); + + /*Dispatching...*/ + switch (IrpContext->MajorFunction) + { + case IRP_MJ_CREATE: + //Status=FsCreate(IrpContext,Irp); + break; + case IRP_MJ_READ: + //Status=FsRead(IrpContext,Irp); + break; + case IRP_MJ_WRITE: + //Status=FsWrite(IrpContext,Irp); + break; + case IRP_MJ_CLOSE: + //Status=FsClose(IrpContext,Irp); + break; + case IRP_MJ_QUERY_INFORMATION: + //Status=FsQueryInfo(IrpContext,Irp); + break; + case IRP_MJ_SET_INFORMATION: + //Status=FsSetInfo(IrpContext,Irp); + break; + case IRP_MJ_QUERY_VOLUME_INFORMATION: + //Status=FsQueryVolInfo(IrpContext,Irp); + break; + case IRP_MJ_DIRECTORY_CONTROL: + //Status=FsDirControl(IrpContext,Irp); + break; + case IRP_MJ_PNP: + //Status=FsPnp(IrpContext,Irp); + break; + case IRP_MJ_CLEANUP: + //Status=FsCleanup(IrpContext,Irp); + break; + case IRP_MJ_LOCK_CONTROL: + //Status=FsLockControl(IrpContext,Irp); + break; + case IRP_MJ_FILE_SYSTEM_CONTROL: + Status=FsFileSysControl(IrpContext,Irp); + default: + break; + } + + /*Release the lock */ + FsRtlExitFileSystem(); + + return Status; +} + +/************************************************************************************/ +PIRP_CONTEXT NTAPI + CreateIrpContext( + IN PIRP Irp, + IN BOOLEAN Wait + ) +{ + PIRP_CONTEXT IrpContext=NULL; + /*Getting parameters*/ + PIO_STACK_LOCATION IrpStackLocation=IoGetCurrentIrpStackLocation(Irp); + + /*Make sure that we are not at IRQL > APC_LEVEL*/ + PAGED_CODE(); + + /*Allocate memory for IrpContext*/ + if (IrpContext==NULL){ + IrpContext=(PIRP_CONTEXT)FsRtlAllocatePoolWithTag(NonPagedPool,sizeof(IRP_CONTEXT),'IRCO'); + } + + /*Zero it*/ + RtlZeroMemory(IrpContext,sizeof(IRP_CONTEXT)); + + /*Set Irp*/ + IrpContext->Irp=Irp; + + /*Checking for a vaild FILE_OBJECT */ + if (IrpStackLocation->FileObject!=NULL){ + /*Setting the device object.*/ + IrpContext->RealDevice=IrpStackLocation->FileObject->DeviceObject; + } + + /* Is this our file system device object? */ + if (IrpStackLocation->DeviceObject!=UdfData.DeviceObjectGlobal){ + /*If it not, initialize VCB structure*/ + IrpContext->Vcb=&((PVOL_DEV_OBJ)IrpStackLocation->DeviceObject)->Vcb; + } + + /*Setting the MajorFunction and MinorFunction */ + IrpContext->MajorFunction=IrpStackLocation->MajorFunction; + IrpContext->MinorFunction=IrpStackLocation->MinorFunction; + + /*Setting the wait flag*/ + if (Wait) IrpContext->Flags|= IRPCONTEXT_CANWAIT; + + return IrpContext; +} + +/************************************************************************************/ +VOID NTAPI + CompleteRequest ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp, + IN NTSTATUS Status + ) +{ + DbgPrint("CompleteRequest - Not Implemented. \n"); + return; +} Index: drivers/filesystems/udfs/procs.h =================================================================== --- drivers/filesystems/udfs/procs.h (revision 0) +++ drivers/filesystems/udfs/procs.h (working copy) @@ -0,0 +1,73 @@ +#include +#include +#include +#include "udf.h" +#include "ecma167.h" + + +UDF_GLOBA_DATA UdfData; +FAST_IO_DISPATCH UdfFastIoDispatch; + +NTSTATUS NTAPI InitGlobalData( + IN PDRIVER_OBJECT DriverObject, + IN PDEVICE_OBJECT DeviceName + ); + +PIRP_CONTEXT NTAPI CreateIrpContext( + IN PIRP Irp, + IN BOOLEAN CanWait + ); + +NTSTATUS NTAPI UdfDispatch + ( + IN PDEVICE_OBJECT DeviceObject, + IN PIRP Irp + ); + +NTSTATUS NTAPI FsFileSysControl( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ); + +VOID NTAPI CompleteRequest ( + IN PIRP_CONTEXT IrpContext OPTIONAL, + IN PIRP Irp OPTIONAL, + IN NTSTATUS Status + ); + +NTSTATUS NTAPI MountVolume ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ); + +NTSTATUS NTAPI UserFsctl ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ); + +NTSTATUS NTAPI VerifyVolume ( + IN PIRP_CONTEXT IrpContext, + IN PIRP Irp + ); + +VOID NTAPI NTAPI ReleaseFromLazyWrite + ( + IN PVOID Context + ); + +BOOLEAN NTAPI NTAPI AcquireForLazyWrite + ( + IN PVOID Context, + IN BOOLEAN Wait + ); +NTSTATUS NTAPI PerformDevIoCtrl + ( + IN PIRP_CONTEXT IrpContext, + IN ULONG IoCtrlCode, + IN PDEVICE_OBJECT DevObj, + OUT PVOID OutputBuffer, + IN ULONG OutBuffLen, + IN BOOLEAN InternDevCtrl, + IN BOOLEAN Override, + OUT PIO_STATUS_BLOCK IoStatusBlock + ); \ No newline at end of file Index: drivers/filesystems/udfs/udf.h =================================================================== --- drivers/filesystems/udfs/udf.h (revision 0) +++ drivers/filesystems/udfs/udf.h (working copy) @@ -0,0 +1,111 @@ + + + +#define IRPCONTEXT_CANWAIT 0x00000001 + +typedef struct _UDF_GLOBA_DATA { + ERESOURCE Resource; + LIST_ENTRY VcbListHead; + + PDRIVER_OBJECT DriverObjectGlobal; + PDEVICE_OBJECT DeviceObjectGlobal; + + FAST_IO_DISPATCH FastIoDispatchIo; + + + NPAGED_LOOKASIDE_LIST NonPageFcbList; + NPAGED_LOOKASIDE_LIST ResourceList; + NPAGED_LOOKASIDE_LIST IrpContextList; + NPAGED_LOOKASIDE_LIST NonPageCcbList; + CACHE_MANAGER_CALLBACKS CacheMgrCallbacks; + CACHE_MANAGER_CALLBACKS CacheMgrVolCallbacks; + + LIST_ENTRY AsyncCloseQueue; + ULONG AsyncClosecount; + + LIST_ENTRY DelayedCloseQueue; + ULONG DelayedCloseCount; + + PIO_WORKITEM ColseItem; + FAST_MUTEX GlobalMutex; + +} UDF_GLOBA_DATA; +typedef UDF_GLOBA_DATA *PUDF_GLOBA_DATA; + +typedef enum _VCB_CONDITON { + VcbNotMounted=0, + VcbMountInProgress, + VcbMounted, + VcbInvalid, + VcbDismountInProgres +}VCB_CONDITON; + +typedef struct _VCB { + PVPB Vpb; + PVPB SwapVpb; + PDEVICE_OBJECT VcbDeviceObject; + PDEVICE_OBJECT TargDevObj; + struct _FCB *RootVcb; + + PFILE_LOCK VolLockFileObj; + + LIST_ENTRY VcbLinks; + + ULONG VcbState; + VCB_CONDITON VcbCondition; + + ULONG VcbCleanup; + ULONG VcbReference; + ULONG VcbUserReference; + + ERESOURCE VcbResource; +}VCB; + +typedef VCB *PVCB; + +typedef struct _IRP_CONTEXT { + PIRP Irp; + + PVCB Vcb; + ULONG Flags; + + PDEVICE_OBJECT RealDevice; + + struct _IRP_CONTEXT *TopLevel; + + UCHAR MajorFunction; + UCHAR MinorFunction; + + WORK_QUEUE_ITEM WorkQueueItem; +}IRP_CONTEXT; + +typedef IRP_CONTEXT *PIRP_CONTEXT; + +typedef struct _FCB { + FSRTL_ADVANCED_FCB_HEADER Header; + ERESOURCE MainResource; + PVCB Vcb; + struct _FCB *ParentFcb; + LIST_ENTRY FcbLinks; + ULONG FcbState; + ULONG FileAttributes; + SHARE_ACCESS ShareAccess; +}FCB; + +typedef FCB *PFCB; + +typedef struct _CCB { + ULONG Flags; + PFCB Fcb; + ULONG CurrDirOffset; + UNICODE_STRING FileName; +}CCB; +typedef CCB *PCCB; + +typedef struct _VOL_DEV_OBJ +{ + DEVICE_OBJECT DeviceObject; + VCB Vcb; +}VOL_DEV_OBJ; + +typedef VOL_DEV_OBJ *PVOL_DEV_OBJ; Index: drivers/filesystems/udfs/udfinit.c =================================================================== --- drivers/filesystems/udfs/udfinit.c (revision 0) +++ drivers/filesystems/udfs/udfinit.c (working copy) @@ -0,0 +1,164 @@ +#include "procs.h" + +#define NDEBUG +#include + +/************************************************************************************/ +NTSTATUS NTAPI + DriverEntry + ( + IN PDRIVER_OBJECT DriverObject, + IN PUNICODE_STRING RegistryPath + ) +{ + PDEVICE_OBJECT DeviceObject; + UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Udf"); + NTSTATUS Status; + + DPRINT("UDFS (ISO/IEC 13346)\n"); + + /*Creating the device object*/ + Status=IoCreateDevice(DriverObject, + 0, + &DeviceName, + FILE_DEVICE_DISK_FILE_SYSTEM, + 0, + FALSE, + &DeviceObject); + + /*Check if the operation was successfull*/ + if (!NT_SUCCESS(Status)){ + return Status; + } + + /*Initialize golbal data.*/ + Status=InitGlobalData(DriverObject,DeviceObject); + + /*Delete the DeviceObject if the initialization fail.*/ + if (!NT_SUCCESS(Status)){ + IoDeleteDevice(DeviceObject); + return Status; + } + + + /*Initialize DriverObject dispatch table*/ + DriverObject->MajorFunction[IRP_MJ_CREATE] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_WRITE] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_READ] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_CLOSE] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION]=(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_PNP] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_CLEANUP] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =(PDRIVER_DISPATCH)UdfDispatch; + DriverObject->DriverUnload = NULL; + + /*Initialize CC callbacks*/ + UdfData.CacheMgrCallbacks.AcquireForLazyWrite=AcquireForLazyWrite; + UdfData.CacheMgrCallbacks.ReleaseFromLazyWrite=ReleaseFromLazyWrite; + UdfData.CacheMgrCallbacks.AcquireForReadAhead=AcquireForLazyWrite; + UdfData.CacheMgrCallbacks.ReleaseFromReadAhead=ReleaseFromLazyWrite; + + + + //DriverObject->FastIoDispatch=&UdfFastIoDispatch; + + + /*Adding DeviceObject in global file system queue*/ + IoRegisterFileSystem(DeviceObject); + ObReferenceObject(DeviceObject); + + return(STATUS_SUCCESS); +} +/************************************************************************************/ +BOOLEAN NTAPI + AcquireForLazyWrite + ( + IN PVOID Context, + IN BOOLEAN Wait + ) +{ + DbgPrint("AcquireForLazyWrite - Not Implemented.\n"); + return TRUE; +} +/************************************************************************************/ +VOID NTAPI + ReleaseFromLazyWrite + ( + IN PVOID Context + ) +{ + DbgPrint("ReleaseFromLazyWrite - Not Implemented.\n"); + return; +} + +/************************************************************************************/ +NTSTATUS NTAPI + InitGlobalData + ( + IN PDRIVER_OBJECT DriverObject, + IN PDEVICE_OBJECT DeviceObject + ) +{ + + //TODO: Initialize CRC + + /*Zero UdfData */ + RtlZeroMemory(&UdfData,sizeof(UDF_GLOBA_DATA)); + + /*Zero UdfFastIoDispatch */ + RtlZeroMemory(&UdfFastIoDispatch,sizeof(FAST_IO_DISPATCH)); + + /*Setting the global DriverObject and DeviceObject*/ + UdfData.DriverObjectGlobal=DriverObject; + UdfData.DeviceObjectGlobal=DeviceObject; + + + /*Initialize VCB list*/ + InitializeListHead(&UdfData.VcbListHead); + + /*Initialize ERESOURCE */ + ExInitializeResourceLite(&UdfData.Resource); + + /*Initialize FCB lookside list*/ + ExInitializeNPagedLookasideList(&UdfData.NonPageFcbList, + NULL, + NULL, + 0, + sizeof(FCB), + 'FCBL', + 0); + + /*Initialize CCB lookside list*/ + ExInitializeNPagedLookasideList(&UdfData.NonPageCcbList, + NULL, + NULL, + 0, + sizeof(CCB), + 'CCBL', + 0); + + /*Initialize IRP_CONTEXT lookside list*/ + ExInitializeNPagedLookasideList(&UdfData.IrpContextList, + NULL, + NULL, + 0, + sizeof(IRP_CONTEXT), + 'IRPC', + 0); + + /*Initialize lists*/ + InitializeListHead(&UdfData.AsyncCloseQueue); + InitializeListHead(&UdfData.DelayedCloseQueue); + + /*Alloc a work item*/ + UdfData.ColseItem=IoAllocateWorkItem(DeviceObject); + /*Initialize mutex */ + ExInitializeFastMutex(&UdfData.GlobalMutex); + + return STATUS_SUCCESS; +} Index: drivers/filesystems/udfs/udfs.rc =================================================================== --- drivers/filesystems/udfs/udfs.rc (revision 0) +++ drivers/filesystems/udfs/udfs.rc (working copy) @@ -0,0 +1,5 @@ +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "UDFS ISO/IEC 13346 Driver\0" +#define REACTOS_STR_INTERNAL_NAME "udfs\0" +#define REACTOS_STR_ORIGINAL_FILENAME "udfs.sys\0" +#include