AutoIt Français

Code : Tout sélectionner

;' This script burns a boot image and data files to disc in a
;' single session  using files from a single directory tree.

;'Copyright (C) Australopitheque


;' *** CD/DVD disc file system types
const $FsiFileSystemNone = 0
Const $FsiFileSystemISO9660 = 1
Const $FsiFileSystemJoliet = 2
Const $FsiFileSystemUDF = 4
const $FsiFileSystemUnknown = 0x40000000


Dim $index      ;'Index to recording drive.
Dim $recorder   ;'Recorder object
Dim $path       ;'Directory of files to burn
Dim $stream     ;'Data stream for burning device
Dim $bootFile   ;'Path and file name of bootimage

$index = 0              ;' First drive on the system
$path = FileSelectFolder("doosier à graver",@windowsdir & "\BurnDir")
$bootFile = FileOpenDialog("fichier boot",@WindowsDir & "\bootimg", "bootimg (*.img)", 1 + 4 )

;' Create a DiscMaster2 object to connect to CD/DVD drives.
Dim $g_DiscMaster
$g_DiscMaster = ObjCreate("IMAPI2.MsftDiscMaster2")

;' Create a DiscRecorder object for the specified burning device.
Dim $uniqueId
$recorder = ObjCreate("IMAPI2.MsftDiscRecorder2")
$uniqueId = $g_DiscMaster.Item($index)
$recorder.InitializeDiscRecorder($uniqueId )

;' -------- Adding Boot Image Code -----
Dim $bootOptions
MsgBox(0, Default, "Creation BootOptions")
$bootOptions = ObjCreate("IMAPI2FS.BootOptions")
$bootOptions.Manufacturer = "Microsoft"
$bootOptions.PlatformId   = 0       ;' x86 processor
$bootOptions.Emulation    = 0       ;' EmulationType.EmulationNone

;' Need a stream for the boot image file
Const $adFileTypeBinary = 1
Dim $bootStream
$bootStream = ObjCreate("ADODB.Stream")
MsgBox(0, Default, "Creation IStream avec bootfile " & $bootFile)
$bootStream.Open
$bootStream.Type = $adFileTypeBinary
$bootStream.LoadFromFile($bootFile)
$bootOptions.AssignBootImage($bootStream)

;' Create disc file system image (ISO9660)
Dim $FSI
$FSI = ObjCreate("IMAPI2FS.MsftFileSystemImage")
$FSI.ChooseImageDefaults($Recorder)

;' Add the boot directory and its contents to the file system
$FSI.BootImageOptions = $bootOptions

;' Add the content directory and files to the file system
$FSI.root.AddTree($path, FALSE)

Dim $result
$result = $FSI.CreateResultImage()
$stream = $result.ImageStream

;' Create and write stream to disc using the specified recorder.
Dim $dataWriter
$dataWriter = ObjCreate("IMAPI2.MsftDiscFormat2Data")
$dataWriter.recorder = $Recorder
$dataWriter.ClientName = "IMAPIv2 TEST"

$dataWriter.write($stream)
MsgBox(0, Default, "----- Gravure Finnish -----")
Exit
 

Code : Tout sélectionner

Imports System
Imports System.Runtime.InteropServices
Imports System.IO
Imports System.Text
Imports System.Threading
Imports System.Collections.Generic
Imports System.Windows.Forms

''' <summary>
''' Classe fournissant des méthodes de lecture et d'extraction du contenu d'une image ISO 9660.
''' </summary>
''' <remarks></remarks>
Public Class ISOReader

    Inherits OffsetConst

    Dim CDFS_SIZE As Integer = 2048                           'Taille d'un block d'une image ISO (CDFS).

    'Attribut fichiers (contenu dans le membre Flag d'un DirectoryRecord)
    Const RECORD_FLAG_HIDDEN As Integer = 1
    Const RECORD_FLAG_DIRECTORY As Integer = 2
    Const RECORD_FLAG_ASSOCIATED As Integer = 4
    Const RECORD_FLAG_RECFMTSPEC As Integer = &H8
    Const RECORD_FLAG_PERM As Integer = &H16
    Const RECORD_FLAG_NOTFINAL As Integer = &H80

    Dim m_fsISO As FileStream
    Dim m_brISO As BinaryReader
    Dim m_ISOfile As String
    Dim m_PrimVolDesc As PrimaryVolumeDescriptor
    Dim m_Directories As New List(Of String)()
    Dim m_Files As New List(Of String)()
    Dim m_BasicFilesInfo As New List(Of BasicRecordFileInfo)()
    Dim m_Status As Integer = Integer.MinValue
    Dim m_TotalFilesSize As UInteger = 0
    Dim m_NumOfDirectories As Integer = 0
    Dim m_NumOfFiles As Integer = 0

    Dim szFindIndexPath As String
    Dim szTmpOutputCreateDir As String

    ''' <summary>
    ''' Evénement pour l'extraction des fichiers de l'ISO.
    ''' </summary>
    ''' <remarks></remarks>
    Public Event Extraction As EventHandler(Of ExtractIsoContentEventArgs)

    ''' <summary>
    ''' Evénement pour la fin d'une extraction.
    ''' </summary>
    ''' <remarks></remarks>
    Public Event Terminate As EventHandler

    ''' <summary>
    ''' Nombre de fichiers contenus dans l'ISO.
    ''' </summary>
    Public ReadOnly Property NumOfFiles() As Integer
        Get
            Return m_NumOfFiles
        End Get
    End Property

    ''' <summary>
    ''' Nombre de répertoires contenus dans l'ISO.
    ''' </summary>
    Public ReadOnly Property NumOfDirectories() As Integer
        Get
            Return m_NumOfDirectories
        End Get
    End Property

    ''' <summary>
    ''' Taille totale occupé par les fichiers.
    ''' </summary>
    Public ReadOnly Property TotalFilesSize() As UInteger
        Get
            Return m_TotalFilesSize
        End Get
    End Property

    ''' <summary>
    ''' Idem que GetLastWin32Error pour la classe.
    ''' </summary>
    Public ReadOnly Property Status() As Integer
        Get
            Return m_Status
        End Get
    End Property

    ''' <summary>
    ''' Obtient les informations contenues dans le descripteur de l'ISO.
    ''' </summary>
    Public ReadOnly Property GetPrimaryVolumeDescriptor() As PrimaryVolumeDescriptor
        Get
            Return m_PrimVolDesc
        End Get
    End Property


    ''' <summary>
    ''' Récupère les listes des répertoires et fichiers trouvés dans l'ISO.
    ''' </summary>
    ''' <param name="dirs">(Out) Retourne une liste des répertoires.</param>
    ''' <param name="files">(Out) Retourne une liste des fichiers.</param>
    Public Sub ParseContent(ByRef dirs As List(Of String), ByRef files As List(Of String))

        If m_Status = 1 Then
            m_fsISO = New FileStream(m_ISOfile, FileMode.Open, FileAccess.Read, FileShare.Read)
            m_brISO = New BinaryReader(m_fsISO)

            Dim datas As Byte() = ReadBlocks(Convert.ToUInt32(CDFS_SIZE), m_PrimVolDesc.TypeLPathTable, SeekOrigin.Begin)

            m_Files = New List(Of String)()
            m_Directories = New List(Of String)()
            m_BasicFilesInfo = New List(Of BasicRecordFileInfo)()

            m_NumOfDirectories = 0
            m_NumOfFiles = 0
            m_TotalFilesSize = 0

            Dim bParseDirs As Boolean = ParseDirsTable(datas, Convert.ToInt32(m_PrimVolDesc.PathTableSize))
            Dim bParseFiles As Boolean = ParseFilesTable(m_ISOfile, "\", m_PrimVolDesc.RootDirectoryRecord.Extent, m_PrimVolDesc.RootDirectoryRecord.Size)

            If (bParseDirs And bParseFiles) Then
                m_Status = 2
            Else
                m_Status = -8

                datas = Nothing

                m_brISO.Close()
                m_fsISO.Close()
                m_fsISO.Dispose()
            End If

        Else

            m_Status = -7

        End If

        dirs = m_Directories
        files = m_Files

    End Sub

    ''' <summary>
    ''' Lit le descripteur de l'ISO (Primary Volume Descriptor).
    ''' </summary>
    ''' <param name="file">Fichier source .iso.</param>
    Public Sub ReadVolumeDescriptor(ByVal f As String)

        m_ISOfile = f

        'Si fichier iso inexistant on quitte.
        If File.Exists(m_ISOfile) = False Then
            m_Status = -10
            Return
        End If

        'Ouvre un flux sur le fichier ISO en lecture seulement.
        m_fsISO = New FileStream(m_ISOfile, FileMode.Open, FileAccess.Read, FileShare.Read)
        m_brISO = New BinaryReader(m_fsISO)

        'Déplacement vers le Primary Volume Descriptor (offset 32768).
        'Sa taille est de 2048 octets.
        m_brISO.BaseStream.Seek(16 * CDFS_SIZE, SeekOrigin.Begin)

        'Lecture et remplissage du buffer.
        Dim buff As Byte() = New Byte(CDFS_SIZE - 1) {}
        m_brISO.Read(buff, 0, CDFS_SIZE)

        '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        '''''''''''''Lecture des champs du Descripteur'''''''''''''''''
        '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        m_PrimVolDesc.Type = buff(OFFSET_TYPE)
        m_PrimVolDesc.ID = ASCIIEncoding.Default.GetString(buff, OFFSET_ID, 6)
        m_PrimVolDesc.Version = buff(OFFSET_VERSION)

        If m_PrimVolDesc.ID.Substring(0, 5).Equals("CD001") = False Then

            m_Status = -9
            GoTo Close

        End If

        m_PrimVolDesc.SystemID = ASCIIEncoding.Default.GetString(buff, OFFSET_SYSTEM_ID, 32).Trim()
        m_PrimVolDesc.VolumeID = ASCIIEncoding.Default.GetString(buff, OFFSET_VOLUME_ID, 32).Trim()
        m_PrimVolDesc.VolumeSpaceSize = Convert.ToInt64(BitConverter.ToInt32(buff, OFFSET_VOLUME_SPACE_SIZE))
        m_PrimVolDesc.VolumeSetSize = buff(OFFSET_VOLUME_SET_SIZE)
        m_PrimVolDesc.VolumeSequenceNumber = buff(OFFSET_VOLUME_SEQUENCE_NUMBER)
        m_PrimVolDesc.LogicalBlockSize = BitConverter.ToInt16(buff, OFFSET_LOGICAL_BLOCK_SIZE)
        m_PrimVolDesc.PathTableSize = BitConverter.ToUInt32(buff, OFFSET_PATH_TABLE_SIZE)
        m_PrimVolDesc.TypeLPathTable = BitConverter.ToUInt32(buff, OFFSET_TYPE_L_PATH_TABLE)
        m_PrimVolDesc.OptTypeLPathTable = BitConverter.ToUInt32(buff, OFFSET_OPT_TYPE_L_PATH_TABLE)
        m_PrimVolDesc.TypeMPathTable = BitConverter.ToUInt32(buff, OFFSET_TYPE_M_PATH_TABLE)
        m_PrimVolDesc.OptTypeMPathTable = BitConverter.ToUInt32(buff, OFFSET_OPT_TYPE_M_PATH_TABLE)

        Dim rootBuffer As Byte() = New Byte(33) {}
        Buffer.BlockCopy(buff, OFFSET_ROOT_DIRECTORY_RECORD, rootBuffer, 0, 33)

        'Root Directory
        Dim RootDir As New DirectoryRecord()
        RootDir.Length = rootBuffer(OFFSET_DIR_REC_LENGTH)
        RootDir.ExtAttrLength = rootBuffer(OFFSET_DIR_REC_EXT_ATTR_LENGTH)
        RootDir.Extent = BitConverter.ToUInt32(rootBuffer, OFFSET_DIR_REC_EXTENT)
        RootDir.Size = BitConverter.ToUInt32(rootBuffer, OFFSET_DIR_REC_SIZE)
        RootDir.filedate = New Byte(6) {}
        Buffer.BlockCopy(rootBuffer, OFFSET_DIR_REC_DATE, RootDir.filedate, 0, 6)
        RootDir.Flags = rootBuffer(OFFSET_DIR_REC_FLAGS)
        RootDir.FileUnitSize = rootBuffer(OFFSET_DIR_REC_FILE_UNIT_SIZE)
        RootDir.Interleave = rootBuffer(OFFSET_DIR_REC_INTERLEAVE)
        RootDir.VolumeSequenceNumber = rootBuffer(OFFSET_DIR_REC_VOLUME_SEQUENCE_NUMBER)
        RootDir.NameLen = rootBuffer(OFFSET_DIR_REC_NAME_LEN)
        RootDir.Name = ASCIIEncoding.Default.GetString(rootBuffer, OFFSET_DIR_REC_NAME, RootDir.NameLen).Trim()

        m_PrimVolDesc.RootDirectoryRecord = RootDir

        m_PrimVolDesc.VolumeSetID = ASCIIEncoding.Default.GetString(buff, OFFSET_VOLUME_SET_ID, 128).Trim()
        m_PrimVolDesc.PublisherID = ASCIIEncoding.Default.GetString(buff, OFFSET_PUBLISHER_ID, 128).Trim()
        m_PrimVolDesc.PreparerID = ASCIIEncoding.Default.GetString(buff, OFFSET_PREPARER_ID, 128).Trim()
        m_PrimVolDesc.ApplicationID = ASCIIEncoding.Default.GetString(buff, OFFSET_APPLICATION_ID, 128).Trim()
        m_PrimVolDesc.CopyrightFileID = ASCIIEncoding.Default.GetString(buff, OFFSET_COPYRIGHT_FILE_ID, 37).Trim()
        m_PrimVolDesc.AbstractFileID = ASCIIEncoding.Default.GetString(buff, OFFSET_ABSTRACT_FILE_ID, 37).Trim()
        m_PrimVolDesc.BibliographicFileID = ASCIIEncoding.Default.GetString(buff, OFFSET_BIBLIOGRAPHIC_FILE_ID, 37).Trim()

        Dim szdate As String = ASCIIEncoding.Default.GetString(buff, OFFSET_CREATION_DATE, 15)
        m_PrimVolDesc.CreationDate = ToDate(szdate)

        szdate = ASCIIEncoding.Default.GetString(buff, OFFSET_MODIFICATION_DATE, 15)
        m_PrimVolDesc.ModificationDate = ToDate(szdate)

        szdate = ASCIIEncoding.Default.GetString(buff, OFFSET_EXPIRATION_DATE, 15)
        m_PrimVolDesc.ExpirationDate = ToDate(szdate)

        szdate = ASCIIEncoding.Default.GetString(buff, OFFSET_EFFECTIVE_DATE, 15)
        m_PrimVolDesc.EffectiveDate = ToDate(szdate)

        m_PrimVolDesc.FileStructureVersion = buff(OFFSET_FILE_STRUCTURE_VERSION)


        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        ''''''''''''''Fin de la lecture des champs du Descripteur'''''''''''''''''''
        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

        'Status OK pour la suite des méthodes.
        m_Status = 1

        'Définit la taille des blocs de données de l'image ISO.
        CDFS_SIZE = m_PrimVolDesc.LogicalBlockSize

        GoTo Close

Close:
        m_brISO.Close()
        m_fsISO.Close()
        m_fsISO.Dispose()

    End Sub

    ''' <summary>
    ''' Extrait un fichier de l'ISO.
    ''' </summary>
    ''' <param name="path">Fichier à extraire.</param>
    ''' <param name="output">Emplacement de destination où copier le fichier.</param>
    Public Sub ExtractFile(ByVal path As String, ByVal output As String)

        'Si on a lu le contenu des chemins de fichiers on peut continuer.
        If m_Status = 2 Then

            'Obtenir l'index dans la liste _BasicFilesInfo
            '(contient toute les infos sur les fichiers dans l'image) du fichier à extraire.
            szFindIndexPath = path
            Dim idx As Integer = m_BasicFilesInfo.FindIndex(AddressOf FindIndex)

            'Nouveau thread pour éxecuter l'extraction du fichier.
            Dim th As Thread = New Thread(New ParameterizedThreadStart(AddressOf ThExtractFile))

            th.Name = "ExtractFileMethod"      'Nom du thread.
            th.Start(New Object() {ExtractMode.EXTRACT_FILE, idx, output})   'Params. passés à la méthodes (mode d'extraction + index + fichier sortie)

            m_Status = 3

        Else

            m_Status = -6

        End If

    End Sub

    Private Sub ForEachCreateDirs(ByVal value As String)

        If value.Equals("\") = False Then
            Directory.CreateDirectory(Path.Combine(szTmpOutputCreateDir, value.Substring(1)))
        End If

    End Sub

    ''' <summary>
    ''' Extrait entièrement l'ISO.
    ''' </summary>
    ''' <param name="output">Dossier de sortie.</param>
    Public Sub ExtractIso(ByVal output As String)

        Try

            'Si le répertoire de sortie est inexistant on le crée.
            If Directory.Exists(output) = False Then
                Directory.CreateDirectory(output)
            End If

            'Vérifie que l'on dispose d'assez d'espace disque pour extraire l'image.
            If (m_TotalFilesSize < New DriveInfo(output.Substring(0, 3)).AvailableFreeSpace) Then

                szTmpOutputCreateDir = output

                'Création des répertoires avant l'extraction des fichiers.
                m_Directories.ForEach(AddressOf ForEachCreateDirs)

                'Nouveau thread pour éxecuter l'extraction de l'ensemble des fichiers.
                Dim th As Thread = New Thread(New ParameterizedThreadStart(AddressOf ThExtractIso))

                th.Name = "ExtractIsoMethod"   'Nom du thread.
                th.Start(New Object() {ExtractMode.EXTRACT_ISO, output})   'Params. passés à la méthodes (mode d'extraction + rép. de sortie)

            Else
                m_Status = -5
            End If

        Catch ex As Exception

        End Try

    End Sub

    ''' <summary>
    ''' Méthode chargée d'extraire l'ISO entièrement.
    ''' </summary>
    ''' <param name="param">Params passé la méthode appelante ExtractIso.</param>
    ''' <remarks>S'éxecute dans le thread ExtractIsoMethod.</remarks>
    Private Sub ThExtractIso(ByVal param As Object)

        'Récupération des params. passés à la méthode.
        Dim oParams As Object() = CType(param, Object())
        Dim em As ExtractMode = CType(oParams(0), ExtractMode)
        Dim szoutput As String = oParams(1).ToString()
        Dim c As UInteger = 0

        'Ouvre un flux sur le fichier ISO en lecture seulement.
        m_fsISO = New FileStream(m_ISOfile, FileMode.Open, FileAccess.Read, FileShare.Read, CDFS_SIZE * 32)
        m_brISO = New BinaryReader(m_fsISO)

        'Itération sur l'ensemble des fichiers trouvés.
        For Each f As BasicRecordFileInfo In m_BasicFilesInfo
            ThExtractFile(New Object() {em, c, szoutput})
            c += 1
        Next

        'Une fois terminée ferme le fichier ISO et libère les resources utilisées.
        m_brISO.Close()
        m_fsISO.Close()
        m_fsISO.Dispose()

        'Levé de l'évément Terminate indiquant la fin de l'extraction de l'image ISO.
        RaiseEvent Terminate(Nothing, EventArgs.Empty)

    End Sub

    ''' <summary>
    ''' Méthode chargée d'extraire un fichier particulier de l'ISO.
    ''' </summary>
    ''' <param name="param">Params passé la méthode appelante ExtractFile.</param>
    ''' <remarks>S'éxecute dans le thread ExtractFileMethod.</remarks>
    Private Sub ThExtractFile(ByVal param As Object)

        'Récupération des params. passés à la méthode.
        Dim oParams As Object() = CType(param, Object())
        Dim em As ExtractMode = CType(oParams(0), ExtractMode)
        Dim idx As Integer = Convert.ToInt32(oParams(1))

        'Info permettant l'extraction du fichier.
        Dim RecInfo As BasicRecordFileInfo = m_BasicFilesInfo(idx)

        'Fichier de sortie.
        Dim szoutput As String = ""
        If em = ExtractMode.EXTRACT_FILE Then
            szoutput = Path.Combine(oParams(2).ToString(), Path.GetFileName(RecInfo.Name))
        Else
            szoutput = Path.Combine(oParams(2).ToString(), RecInfo.Name.Substring(1))
        End If

        'Définition des positions du fichier dans l'ISO.
        RecInfo.Extent *= Convert.ToUInt32(CDFS_SIZE)                  'Position de départ.
        Dim uiLength As UInteger = RecInfo.Extent + RecInfo.Size      'Position de fin.

        'Si on a choisi d'extraire simplement un fichier et non pas l'ISO complète
        '(Evite d'ouvrir le fichier ISO à chaque fichier à extraire si extraction ISO complète)
        'On ouvre un flux sur le fichier ISO en lecture seulement avec 64KB en mémoire tampon.
        If em = ExtractMode.EXTRACT_FILE Then
            m_fsISO = New FileStream(m_ISOfile, FileMode.Open, FileAccess.Read, FileShare.Read, CDFS_SIZE * 32)
            m_brISO = New BinaryReader(m_fsISO)
        End If

        'Ouvre un flux en écriture sur le fichier de sortie
        Dim fsDst As FileStream = New FileStream(szoutput, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, CDFS_SIZE * 32)
        Dim bwDst As BinaryWriter = New BinaryWriter(fsDst)

        'Init. le buffer recevant les blocs à copier.
        Dim buff As Byte() = New Byte() {}

        'Définit la position du fichier dans l'ISO.
        m_brISO.BaseStream.Seek(RecInfo.Extent, SeekOrigin.Begin)

        'Itération sur la position du curseur dans la plage de données du fichier.
        Do While (m_brISO.BaseStream.Position < uiLength)

            Dim pos As Long = m_brISO.BaseStream.Position      'Posisiton actuelle.

            'Si il reste moins de 64KB à copier
            If ((CDFS_SIZE * 32) + pos) > uiLength Then

                buff = New Byte(uiLength - pos - 1) {}
                m_brISO.Read(buff, 0, buff.Length)  'Lecture de la fin des données.

            Else

                buff = New Byte((CDFS_SIZE * 32) - 1) {}
                m_brISO.Read(buff, 0, buff.Length)  'Lecture du bloc de données suivant.

            End If

            'Ecrit dans le fichier de sortie.
            bwDst.Write(buff)
            bwDst.Flush()

            'Levé de l'événement Extraction renseignant sur la progression de l'extraction.
            RaiseEvent Extraction(Nothing, New ExtractIsoContentEventArgs(RecInfo.Name, RecInfo.Extent, _
                        uiLength - RecInfo.Extent, Convert.ToUInt32(pos) - RecInfo.Extent, szoutput, idx + 1))

        Loop

        'Si on est en mode extraction fichier simple
        'On ferme le fichier ISO et libère les ressources utilisées.
        If em = ExtractMode.EXTRACT_FILE Then

            m_brISO.Close()
            m_fsISO.Close()
            m_fsISO.Dispose()

            'Levé de l'évément Terminate indiquant la fin de l'extraction de l'image ISO.
            RaiseEvent Terminate(Nothing, EventArgs.Empty)

        End If

        'Ferme le fichier de sortie.
        bwDst.Close()
        fsDst.Close()
        fsDst.Dispose()

        'Inscrit la date d'origine sur le fichier extrait.
        File.SetLastWriteTime(szoutput, RecInfo.GetDate())

    End Sub

    ''' <summary>
    ''' Lit la table des répertoires.
    ''' </summary>
    ''' <param name="datas">Bloc de données contenant la table des chemins des répertoires.</param>
    ''' <param name="size">Taille de la table des chemins.</param>
    ''' <returns>True si lecture OK; False si non.</returns>
    Private Function ParseDirsTable(ByVal datas As Byte(), ByVal size As Integer) As Boolean

        Dim bret As Boolean = True
        Dim iNameLength As Integer
        Dim i As Integer = 0
        Dim usParentIndex As UShort
        Dim szName As String
        Dim iCountDir As Integer = 0

        Dim bufParentIdx As Byte() = New Byte(1) {}

        Try

            'Itération sur la table des chemins
            While (i > -1)

                iNameLength = datas(i)     'Taille du chemin suivant.

                'Récupère l'index du chemins parent auquel ce chemin appartient.
                Buffer.BlockCopy(datas, i + 6, bufParentIdx, 0, 2)
                usParentIndex = BitConverter.ToUInt16(bufParentIdx, 0)

                Dim bufName As Byte() = New Byte(iNameLength - 1) {}

                'Récupère son nom
                Buffer.BlockCopy(datas, i + 8, bufName, 0, iNameLength)
                szName = ASCIIEncoding.Default.GetString(bufName)


                If String.IsNullOrEmpty(szName) = False AndAlso Strings.AscW(szName) = 0 Then
                    szName = "\"
                End If

                'Si nom valide
                If String.IsNullOrEmpty(szName) = False Then

                    m_NumOfDirectories += 1    'Incrémente le compteur répertoire

                    'Puis ajoute à liste des chemins
                    If szName.Equals("\") = False Then
                        m_Directories.Add(Path.Combine(m_Directories(usParentIndex - 1), szName))
                    Else
                        m_Directories.Add(szName)
                    End If

                End If

                iCountDir += 1    'Avance au chemin suivant.

                'Quand la lecture de la table est fini on sort.
                If i >= size Then
                    Return True
                End If

                i += iNameLength + 8

                If (iNameLength Mod 2) > 0 Then
                    i += 1
                End If

                If iNameLength = 0 Then       'Si pas de chemin passe au suivant.
                    i += 1
                End If

                If usParentIndex = 0 Then     'Si chemins trouvé = racine on passe au suivant.
                    i += 1
                End If

            End While

        Catch ex As Exception

            bret = False

        End Try

        Return bret

    End Function

    ''' <summary>
    ''' Lit la table des fichiers.
    ''' </summary>
    ''' <param name="path">Chemin à lire. (récupérer dans la table des chemins).</param>
    ''' <param name="parent">Chemin parent.</param>
    ''' <param name="start">Position de départ d'un bloc DirectoryRecord (infos sur le chemin).</param>
    ''' <param name="length">Taille du bloc DirectoryRecord.</param>
    ''' <returns>True si lecture OK; False si non.</returns>
    Private Function ParseFilesTable(ByVal p As String, ByVal parent As String, ByVal start As UInteger, ByVal length As UInteger) As Boolean

        Dim i As Integer = 0
        Dim uiExtent As UInteger = 0
        Dim uiSize As UInteger = 0
        Dim bFlagDir As Boolean = False
        Dim iNameLength As Integer = 0
        Dim szName As String = ""
        Dim da As Byte() = New Byte() {}
        Dim lstDir As New List(Of BasicRecordFileInfo)()

        Try

            Dim buff As Byte() = ReadBlocks(length, start, SeekOrigin.Begin)

            'Itération sur chaque structure DirectoryRecord de la table des fichiers.
            '(PI: Voir les champs de la structure)
            While (i > -1)

                Dim iRecordLength As Integer = buff(i)      'Taille de la structure.

                'Si contient des données.
                If iRecordLength > 0 Then

                    Dim bufRecord As Byte() = New Byte(3) {}

                    'Extent - Position de départ du fichier.
                    Buffer.BlockCopy(buff, i + OFFSET_DIR_REC_EXTENT, bufRecord, 0, 4)
                    uiExtent = BitConverter.ToUInt32(bufRecord, 0)

                    bufRecord = New Byte(3) {}

                    'Size - Taille du fichier
                    Buffer.BlockCopy(buff, i + OFFSET_DIR_REC_SIZE, bufRecord, 0, 4)
                    uiSize = BitConverter.ToUInt32(bufRecord, 0)

                    bufRecord = New Byte(6) {}

                    'Récupère la date
                    Buffer.BlockCopy(buff, i + OFFSET_DIR_REC_DATE, bufRecord, 0, 7)
                    da = bufRecord

                    'Flag du chemin (test si c'est un répertoire).
                    bFlagDir = Convert.ToBoolean(buff(i + OFFSET_DIR_REC_FLAGS) And RECORD_FLAG_DIRECTORY)

                    'Longeur du chemin.
                    iNameLength = buff(i + OFFSET_DIR_REC_NAME_LEN)

                    'Récupère le nom du chemin du fichier.
                    szName = ASCIIEncoding.Default.GetString(buff, i + OFFSET_DIR_REC_NAME, iNameLength)

                    'Si nom n'est pas vide.
                    If String.IsNullOrEmpty(szName) = False Then

                        'Et caractère valide.
                        If ASCIIEncoding.Default.GetBytes(szName.ToCharArray(), 0, 1)(0) > 1 Then

                            'Si c'est un fichier
                            If bFlagDir = False Then

                                m_Files.Add(path.Combine(parent, szName))
                                m_BasicFilesInfo.Add(New BasicRecordFileInfo(uiExtent, uiSize, da, Path.Combine(parent, szName)))

                                m_TotalFilesSize += uiSize      'Incrémente la taille totale occupés par les fichiers
                                m_NumOfFiles += 1                  'Incrémente le compteur fichiers

                                'Répertoire
                            Else
                                lstDir.Add(New BasicRecordFileInfo(uiExtent, uiSize, da, szName))
                            End If

                        End If

                    End If

                Else

                    'Passe au chemin suivant.
                    iRecordLength = 1

                End If

                i += iRecordLength     'Avance dans le bloc de la table fichiers pour le suivant.

                'Si fin de la table lu on sort de l'itération.
                If i >= length Then
                    i = -1
                End If

            End While

            'Itération sur chaque chemins de répertoires
            'Et lecture des structures des fichiers présents dans ces chemins.
            For j As Integer = 0 To lstDir.Count - 1

                Application.DoEvents()

                Dim brfidir As BasicRecordFileInfo = lstDir(j)
                brfidir.Name += "\"

                ParseFilesTable(p, Path.Combine(parent, "") & Path.Combine(brfidir.Name, ""), brfidir.Extent, brfidir.Size)

            Next

            Return True

        Catch ex As Exception

            Return False

        End Try

    End Function

    ''' <summary>
    ''' Convertie en date un type définis en 8.4.26.1 dans le fichier sur l'ISO de l'ECMA.
    ''' </summary>
    ''' <param name="value"></param>
    ''' <returns></returns>
    Private Function ToDate(ByVal value As String) As DateTime

        If value.Length = 15 Then

            If value.Equals("000000000000000") Then
                Return New DateTime()
            Else

                Dim daRet As DateTime = New DateTime(Integer.Parse(value.Substring(0, 4)), Integer.Parse(value.Substring(4, 2)), Integer.Parse(value.Substring(6, 2)))

                Return daRet

            End If

        Else

            Return New DateTime()

        End If

    End Function

    ''' <summary>
    ''' Lecture d'un nombre de blocs.
    ''' </summary>
    ''' <param name="sectors">Nombre de blocs à lire.</param>
    ''' <param name="offset">Position à atteindre.</param>
    ''' <param name="seek">Point de départ de la recherche.</param>
    ''' <returns>Un tableau d'octets.</returns>
    Private Function ReadBlocks(ByVal sectors As UInteger, ByVal offset As UInteger, ByVal seek As SeekOrigin)

        m_brISO.BaseStream.Seek(offset * CDFS_SIZE, seek)

        Dim buff As Byte() = New Byte((sectors * CDFS_SIZE) - 1) {}

        m_brISO.Read(buff, 0, Convert.ToInt32((sectors) * CDFS_SIZE))

        Return buff

    End Function

    Private Function FindIndex(ByVal value As BasicRecordFileInfo) As Boolean

        Return szFindIndexPath.Equals(value.Name)

    End Function

End Class