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
bien sur on peut mettre des event pour voir la progression de la gravure mais je verrai ça plus tard quand l'essentiel sera fait .
Je n'ai pas assez de connaissances sur le sujet pour te repondre, mais si il y a un script qui marche en c, ca existe en Autoit 
c'est un principe 
.
, y a trop de fonction inconnu 
