Полезные технологии
Все статьи раздела
Доступ к MD-файлам при помощи VBA
Сергей Новодворский (март 2003)
Файлы метаданных V7 (*.md) представляют собой структурированные хранилища
(structured storage), организованные по правилам файловой системы от Microsoft. В терминологии OLE2
сами дисковые файлы носят название "составной файл" (compound file).
Compound file состоит из целого числа блоков данных, размер каждого блока равен 512 байт, т.е.
соответствует одному дисковому сектору, поэтому в дальнейшем я буду пользоваться термином
"сектор" для обозначения блока размером 512 байт.
Нумерация секторов в составном файле начинается с -1: -1,0,1,2…
В стуктуру составного файла входят следующие области данных:
- заголовок файла;
- данные, организованные в виде "больших блоков", занимающие целиком весь сектор;
- данные, организованные в виде "малых блоков" размером по 64 байта, занимают весь сектор,
но в количестве 8 штук;
- данные, представляющие собой "объекты" каталога, размером по 128 байт, занимают весь
сектор в количестве 4 штук;
- таблица размещения в составном файле больших блоков, по сути это FAT (File Allocation Table),
далее "FAT больших блоков";
- таблица размещения собственно самого FAT больших блоков (может отсутствовать, если
FAT вмещается в один сектор);
- таблица размещения в составном файле малых блоков – FAT малых блоков;
- неструктурированные данные (lock-bytes ???).
Прежде чем начать описание структуры и способов получения данных из составного файла, проведем некоторую
подготовительную работу.
Нам придется работать с двоичными данными и переводить числа из шестнадцетеричного в
десятичный формат (учитывая, что числа в файле хранятся в шестнадцатеричном формате начиная
с младшего байта). Для этого в разделе деклараций нашего VBA-модуля создадим две UDT-структуры:
Public Type DWORD_C 'структура для чтения DWORD из файла
b1 As Byte '1 (младший байт)
b2 As Byte '2 байт
b3 As Byte '3 байт
b4 As Byte '4 (старший) байт
End Type
Public Type DWORD_B 'структура для перевода DWORD в LONG
n As Long
End Type
|
и напишем функцию для перемещения содержимого из одной структуры в другую
Public Function HDec(vByte As DWORD_C) As Long
' функция преобразования знаковых длинных целых
Dim mLong As DWORD_B
LSet mLong = vByte
HDec = mLong.n
End Function
|
Объявим там же константу со значением размера сектора и байтовый массив,
в котором будет хранится наш составной файл:
Public Const SECTORSIZE As Long = 512
Public fileBuf() as Byte
|
Далее пишем функцию, которая считает составной файл целиком в байтовый массив
Public Function GetFile() As Boolean
' прочитать файл
Dim iFile As Long ' номер файла
Dim lFile As Long ' размер файла
Dim rc As Boolean ' результат выполнения
Dim mdFileName as Strin ' полное имя файла
On Error Goto errHandler
rc = False ' результат выполнения
' здесь любым доступным способом присвоим переменной mdFileName имя
' составного файла
' . . .
If Len(mdFile) = 0 Then GoTo myExit
iFile = FreeFile()
Open mdFile For Binary As #iFile ' откроем файл в режиме двоичного доступа
lFile = LOF(iFile) ' размер файла
If lFile = 0 Then GoTo myExit
ReDim fileBuf(1 To lFile)
' считать весь файл
Get iFile, , fileBuf()
' закрыть файл
Close iFile
If UBound(fileBuf) = lFile Then
' если файл *.md считан правильно
rc = True
End If
myExit:
GetFile = rc
Exit Function
errHandler:
GetFile = rc
' . . . вывод сообщения об ошибке
End Function
|
Если функция вернула True, значит файл считан в массив fileBuf().
Заголовок составного файла
Заголовок представляет собой запись размером 80 байтов в секторе номер -1. Нас будут интересовать
следующие поля заголовка:
| Смещение |
Размер поля |
Описание |
| Dec |
Hex |
| +1 |
+00h |
DWORD |
Магическое число E011CFD0h (-535703600 при выполнении функции HDec) |
| +45 |
+2Ch |
DWORD |
Количество секторов, которые занимает FAT больших блоков |
| +49 |
+30h |
DWORD |
Номер стартового сектора каталога |
| +61 |
+3Ch |
DWORD |
Номера стартового сектора FAT малых блоков |
| +69 |
+44h |
DWORD |
Номер сектора доп.таблицы размещения FAT больших блоков |
| +77 |
+4Ch |
DWORD |
Номер стартового сектора FAT больших блоков |
Что сие означает – будет рассказано ниже, а пока что в разделе деклараций модуля
создаем UDT структуру:
Public Type FILEHEADER ' это структура для заголовка файла
SizeOfBBD As Long ' кол-во секторов FAT больших блоков
StartBBD As Long ' стартовый сектор FAT больших блоков
StartBBDex As Long ' стартовый сектор доп.таблицы для FAT больших блоков
StartSBD As Long ' стартовый сектор FAT малых блоков
StartRoot As Long ' стартовый сектор каталога
End Type
|
объявляем переменную, которая будет содержать означенную выше структуру
|
Public HeaderMD As FILEHEADER
|
и пишем функцию, которая заполнит стуктуру заголовка составного файла
Public Function GetHeader() As Boolean
' прочитать заголовок файла
Dim i As Long
Dim sText As String
Dim dWord As DWORD_C
Dim x As Long
Dim rc As Boolean
On Error Goto errHandler
rc = False ' результат выполнения
' сектор, в котором расположен заголовок,
' нумеруется как (-1), поэтому для оптимизации
' сразу прибавляем по 1 к стартовым значениям
' т.к. сами считать будем от головы файла
' сигнатура файла
dWord.b1 = fileBuf(1)
dWord.b2 = fileBuf(2)
dWord.b3 = fileBuf(3)
dWord.b4 = fileBuf(4)
sText = Hex(HDec(dWord))
' проверяем на наличие магического числа
If sText <> "E011CFD0" Then
GoTo myExit
End If
' количество секторов в FAT больших блоков
i = &H2C
dWord.b1 = fileBuf(i + 1)
dWord.b2 = fileBuf(i + 2)
dWord.b3 = fileBuf(i + 3)
dWord.b4 = fileBuf(i + 4)
HeaderMD.SizeOfBBD = HDec(dWord)
' стартовый сектор каталога
i = &H30
dWord.b1 = fileBuf(i + 1)
dWord.b2 = fileBuf(i + 2)
dWord.b3 = fileBuf(i + 3)
dWord.b4 = fileBuf(i + 4)
HeaderMD.StartRoot = HDec(dWord) ' здесь порядковый номер сектора
' стартовый сектор FAT малых блоков
i = &H3C
dWord.b1 = fileBuf(i + 1)
dWord.b2 = fileBuf(i + 2)
dWord.b3 = fileBuf(i + 3)
dWord.b4 = fileBuf(i + 4)
HeaderMD.StartSBD = HDec(dWord)
' стартовый сектор таблицы размещения доп.FAT больших блоков
i = &H44
dWord.b1 = fileBuf(i + 1)
dWord.b2 = fileBuf(i + 2)
dWord.b3 = fileBuf(i + 3)
dWord.b4 = fileBuf(i + 4)
x = HDec(dWord)
If x > 0 Then
' вычислить абсолютный адрес только если он больше 0
x = 1 + (x + 1) * SECTORSIZE
End If
HeaderMD.StartBBDex = x
' стартовый сектор FAT больших блоков
i = &H4C
dWord.b1 = fileBuf(i + 1)
dWord.b2 = fileBuf(i + 2)
dWord.b3 = fileBuf(i + 3)
dWord.b4 = fileBuf(i + 4)
' вычисляем абсолютный адрес в файле
HeaderMD.StartBBD = 1 + (HDec(dWord) + 1) * SECTORSIZE
rc = True
myExit:
GetHeader = rc
Exit Function
errHandler:
GetHeader = rc
' . . . вывод сообщения об ошибке
End Function
|
Если функция вернула True, значит заголовок считан и наш файл является составным файлом OLE.
FAT
FAT представляет собой последовательный список 4-байтовых "строчек" DWORD, каждая из которых
соответствует порядковому номеру сектора в файле, начиная с сектора под номером 0 (сектор -1
вообще не учитывается). Значение строчки – это номер сектора, следующего за
текущим. Отрицательное содержимое "строчки" означает следующее:
- -1=FFFFFFFFh – специальный сектор;
- -2=FFFFFFFEh – последний сектор в цепочке;
- -3=FFFFFFFDh – этот сектор не используется.
Все, сказанное о FAT, применяется к FAT больших блоков, однако с малыми блоками и каталогом
дело обстоит не так.
Номер строчки для FAT малых блоков и каталога – это не порядковые номера секторов,
а порядковый номер записи (размером 64 байта или 128 байт соответственно) от начала области,
где располагаются собственно малые блоки или каталог. Первая запись имеет номер 0.
Но вернемся к FAT больших блоков. Первый сектор расположен в файле по абсолютному адресу, который
мы определили из заголовка файла (смещение +4Ch) и записали в HeaderMD.StartBBD. Но
непосредственно в сектор может поместиться только 128 номеров секторов (т.е. файл в принципе
не может быть больше 512 + 128 Х 512 = 66048 байт), а где же тогда искать продолжение FAT?
Вот это был секрет за семью замками и только методом проб и ошибок была обнаружена область, которая
из себя представляет FAT для FAT. Находится она в секторе -1 и занимает оставшуюся от заголовка
файла область начиная с 81 байта (+50h) и до конца сектора. Каждая строчка этой области указывает
на номер сектора, в котором расположен следующий сектор FAT( поэтому FAT для FAT это не совсем
FAT, т.к. значение строчки указывает не на следующий за текущим номер сектора, а прямо адресует
к сектору, где расположен следующий "кусочек" настоящего FAT).
Таким образом мы имеем 109 секторов FAT, каждый из которых адресует 128 секторов составного
файла, т.е. максимальный размер файла может составлять 512 + (109 Х 128 Х 512) = 7 143 936 байт, но
физические-то файлы больше!
Методом всё того же тыка был обнаружен еще один сектор "FAT для FAT", номер которого находится в
заголовке файла (смещение +44h), причем если значение равно -1 (FFFFFFFFh), то такого сектора
в файле нет.
Теперь, когда мы разобрались с местом жительства FAT больших блоков, можно написать программу, которая
вытянет весь FAT в массив. Причем для удобства создадим UDT-структуру (этого можно и не делать),
которая будет содержать ссылку на следующий номер сектора и абсолютный номер текущего сектора
файла. В области деклараций модуля объявляем
Public Type FATSTRUCTURE ' это структура для FAT
Adres As Long ' абс. адрес текущего сектора
Next As Long ' номер следующего сектора
End Type
Public fatBBD() As FATSTRUCTURE ' массив FAT больших блоков
|
И пишем функцию:
Public Function GetFatBBD() As Boolean
' чтение FAT больших блоков
Dim i As Long
Dim x As Long
Dim j As Long
Dim iCount As Long
Dim iMax As Long
Dim dWord As DWORD_C
Dim rc As Boolean
rc = False ' результат выполнения
' определить размер массива для FAT
' размер сектора умн. на кол-во секторов FAT
' и разделить на 4 (кол-во байт DWORD)
x = (SECTORSIZE * HeaderMD.SizeOfBBD)
i = x / 4
If i = 0 Then Exit Function
' определяем массив FAT (начинаем с 0, т.к. сектора в файле нумеруются с 0)
ReDim fatBBD(0 To i - 1)
' записываем данные в массив
x = HeaderMD.StartBBD ' стартовый адрес BBD (абсолютный)
For i = 0 To 127 ' количество слов в секторе
' адрес сектора=порядковый номер сектора в FAT
fatBBD(i).Adres = 1 + (i + 1) * SECTORSIZE
' определяем следующий сектор в FAT
dWord.b1 = fileBuf(x)
dWord.b2 = fileBuf(x + 1)
dWord.b3 = fileBuf(x + 2)
dWord.b4 = fileBuf(x + 3)
fatBBD(i).Next = HDec(dWord)
x = x + 4
Next
' если секторов FAT больше 1
' читаем таблицу в секторе -1
If HeaderMD.SizeOfBBD > 1 Then
iCount = 128 ' следующий номер массива FAT
' цикл по считанным номерам секторов
' адреса номеров блоков FAT BBD начинаются с абс.адреса 81 (десят.)
' по 512 (десят.)
For j = 81 To 512 Step 4
dWord.b1 = fileBuf(j)
dWord.b2 = fileBuf(j + 1)
dWord.b3 = fileBuf(j + 2)
dWord.b4 = fileBuf(j + 3)
x = HDec(dWord)
If x > 0 Then
' вычислить абсолютный адрес только если он больше 0
x = 1 + (x + 1) * SECTORSIZE
' записываем данные в массив
iMax = iCount + 127 ' число слов в секторе
For i = iCount To iMax ' количество слов в секторе
' адрес сектора=порядковый номер сектора в FAT
fatBBD(i).Adres = 1 + (i + 1) * SECTORSIZE
' определяем следующий сектор в FAT
dWord.b1 = fileBuf(x)
dWord.b2 = fileBuf(x + 1)
dWord.b3 = fileBuf(x + 2)
dWord.b4 = fileBuf(x + 3)
fatBBD(i).Next = HDec(dWord)
x = x + 4
Next
' увеличиваем номер массива
iCount = iMax + 1
End If
Next
' если таблица размещения FAT еще не кончилась
If HeaderMD.StartBBDex > 0 Then
' читаем доп.таблицу размещения FAT
' цикл по считанным номерам секторов
For j = HeaderMD.StartBBDex To HeaderMD.StartBBDex + 511 Step 4
dWord.b1 = fileBuf(j)
dWord.b2 = fileBuf(j + 1)
dWord.b3 = fileBuf(j + 2)
dWord.b4 = fileBuf(j + 3)
x = HDec(dWord)
If x > 0 Then
' вычислить абсолютный адрес только если он больше 0
x = 1 + (x + 1) * SECTORSIZE
' записываем данные в массив
iMax = iCount + 127 ' число слов в секторе
For i = iCount To iMax ' количество слов в секторе
' адрес сектора=порядковый номер сектора в FAT
fatBBD(i).Adres = 1 + (i + 1) * SECTORSIZE
' определяем следующий сектор в FAT
dWord.b1 = fileBuf(x)
dWord.b2 = fileBuf(x + 1)
dWord.b3 = fileBuf(x + 2)
dWord.b4 = fileBuf(x + 3)
fatBBD(i).Next = HDec(dWord)
x = x + 4
Next
' увеличиваем номер массива
iCount = iMax + 1
End If
Next
End If
End If
rc = True
myExit:
GetFatBBD = rc
End Function
|
Если функция вернула True, значит FAT считан. Функцию можно разбить на две, но это не существенно.
После того, как мы получили из составного файла FAT больших блоков, пришла пора приступить к
получению FAT малых блоков. Номер стартового сектора FAT малых блоков указан в заголовке
файла (смещение +3С), мы его записали в HeaderMD.StartSBD. Этот номер равен индексу массива
FAT больших блоков, и дальше по цепочке вытягиваем все сектора, в которых расположен FAT малых блоков.
Сейчас самое время написать функцию, которая будет выдавать нам номер следующего сектора.
Функция возвращает ноль, если текущий сектор последний.
Public Function GetNextBigFATSector(iSector As Long) As Long
' получить значение следующего сектора (большой FAT)
Dim x As Long
GetNextBigFATSector = 0
x = fatBBD(iSector).Next
If x > 0 Then
GetNextBigFATSector = x
End If
End Function
|
Почему нужна была структура FATSTRUCTURE? Если для FAT больших блоков можно было
умножением индекса массива на размер сектора плюс 512 узнать абсолютный адрес сектора,
то номера в FAT малых блоков означают относительные номера 64-байтовых записей от начала
области данных малых блоков и, используя указанную структуру, мы будем в процессе создания
массива FAT малых блоков сразу записывать абсолютные адреса для каждого малого блока.
Но для этого надо определить абсолютный адрес сектора, с которого начинается область данных
малых блоков. Адрес этого сектора находится в 128-байтовой записи объекта каталога, являющегося
корнем каталога (Root Entry) по смещению +74h, а сам объект представлен в заголовке файла
(смещение +30h) как стартовый сектор каталога (об объектах каталога речь пойдет позже).
В разделе деклараций объявляем массив FAT малых блоков:
|
Public fatBBD() As FATSTRUCTURE ' массив FAT малых блоков
|
и пишем функцию для получения FAT из файла
Public Function GetFatSBD() As Boolean
' получить FAT малых блоков
Dim i As Long
Dim x As Long
Dim j As Long
Dim iCount As Long
Dim iMax As Long
Dim dWord As DWORD_C
Dim rc As Boolean
rc = False
' определяем количество записей (малых блоков) малого FAT
iMax = 0
' получаем абс.номер сектора FAT
i = fatBBD(HeaderMD.StartSBD).Adres
' номер из FAT
x = HeaderMD.StartSBD
If i <= 0 Then GoTo myExit
' организуем цикл , если абс.сектор>0
Do While i > 0
iMax = iMax + 128
' получаем значение следующего сектора
x = GetNextBigFATSector(x)
If x > 0 Then
i = fatBBD(x).Adres
Else
i = 0
End If
Loop
' определяем размерность массива малого FAT
ReDim fatSBD(0 To iMax - 1)
' опять получаем абс.номер сектора FAT
i = fatBBD(HeaderMD.StartSBD).Adres
' номер слова из FAT
x = HeaderMD.StartSBD
iCount = 0
' опять организуем цикл , если абс.сектор>0
Do While i > 0
' читаем файл
For j = 0 To 127 ' количество слов в секторе
' смещение малого блока=порядковый номер слова в малом FAT
fatSBD(iCount).Adres = 0 ' пока записываем 0
' определяем следующий сектор в FAT
dWord.b1 = fileBuf(i)
dWord.b2 = fileBuf(i + 1)
dWord.b3 = fileBuf(i + 2)
dWord.b4 = fileBuf(i + 3)
fatSBD(iCount).Next = HDec(dWord)
iCount = iCount + 1
i = i + 4
Next
' получаем значение следующего сектора из большого FAT
x = GetNextBigFATSector(x)
If x > 0 Then
i = fatBBD(x).Adres
Else
i = 0
End If
Loop
' теперь вытягиваем абс.адреса блоков SBD
' получаем абс.номер стартового сектора каталога
i = 1 + (HeaderMD.StartRoot+1) * SECTORSIZE
' получаем абс.адрес слова, где указан стартовый блок FAT(+74H)
i = i + 116
dWord.b1 = fileBuf(i)
dWord.b2 = fileBuf(i + 1)
dWord.b3 = fileBuf(i + 2)
dWord.b4 = fileBuf(i + 3)
x = Hdec(dWord)
' получаем абс.номер сектора FAT
i = fatBBD(x).Adres
iCount = 0
' организуем цикл , если абс.сектор>0
Do While i > 0
' всего в секторе восемь 64 байтных блоков
For j = 0 To 511 Step 64
' записываем абсолютный адрес в малый FAT
If fatSBD(iCount).Next <> -1 Then
' если этот сектор используется
fatSBD(iCount).Adres = i + j
End If
iCount = iCount + 1
Next
' получаем значение следующего сектора
x = GetNextBigFATSector(x)
If x > 0 Then
i = fatBBD(x).Adres
Else
i = 0
End If
Loop
rc = True
myExit:
GetFatSBD = rc
End Function
|
и сразу пишем функцию, которая будет возвращать номер следующего малого блока или 0,
если текущий блок последний:
Public Function GetNextSmallFATSector(iSector As Long) As Long
' получить значение следующего сектора (малый FAT)
Dim x As Long
GetNextSmallFATSector = 0
x = fatSBD(iSector).Next
If x > 0 Then
GetNextSmallFATSector = x
End If
End Function
|
Каталог
Каталог представляет собой описание структуры объектов составного файла, упорядоченных
в виде дерева. Сам объект представлен 128-байтной записью со следующими полями (только те,
что нас интересуют):
| Смещение |
Размер поля |
Описание |
| Dec |
Hex |
| +1 |
+00h |
64 байта |
Имя объкта (Unicode) |
| +65 |
+40h |
WORD |
Фактическая длина имени объекта (вместе с завершающим 0) |
| +67 |
+42h |
BYTE |
Тип объекта (1-подкаталог,2-поток(данные),5-корневой каталог) |
| +69 |
+44h |
DWORD |
Номер предыдущего объекта |
| +73 |
+48h |
DWORD |
Номер следующего объекта |
| +77 |
+4Ch |
DWORD |
Номер первого подчиненного объекта |
| +117 |
+74h |
DWORD |
Номер стартового сектора объекта |
| +121 |
+78h |
DWORD |
Размер объекта в байтах |
Как видим, объекты каталога представляют собой связанный список, каждый элемент которого
имеет ссылку на предыдущий,следующий и подчиненный объекты, в свою очередь подчиненные также
имеют своих предудыщих,следующих и подчиненных. Отсутствие какого-либо из перечисленных
обозначается как -1.
Единственное, чего не имеет объект, так это своего собственного номера. А нумеруются они начиная
с нуля 128-байтными "кусочками" относительно области данных каталога, номер стартового сектора
этой области находится в заголовке файла (смещение +30h), а сама область вытягивается из FAT
больших блоков.
Еще одно существенное замечание (оно не касается стартового объекта каталога Root Entry) –
если размер объекта (смещение +78h) больше или равен 4096 байтам (1000h), то номер стартового
сектора (смещение +74h) указывает на FAT больших блоков, в противном случае – на
FAT малых блоков. Стартовый объект всегда находится в FAT больших блоков (ведь, как было показано
выше, там живет адрес области данных малых блоков).
Для построения дерева из связанного списка существует много алгоритмов, предложу свой (не
претендую ни на что! ;-) – просто он как-то сразу заработал.
Создадим модуль класса, назовем его clsNode и напишем следующий код
Option Explicit
Public PrevID As Long
Public NextID As Long
Public NodeName As String
Public NodeType As Long
Public StartNumber As Long
Public NodeSize As Long
Public SmallFat As Boolean
Public Key As String
Public NodeID As Long
Private mCol As New Collection
Private m_FirstChild As Long
Public Function Count() As Long
Count = mCol.Count
End Function
Public Function Item(vItem As Variant) As clsNode
Set Item = mCol.Item(vItem)
End Function
Public Property Get FirstChild() As Long
FirstChild = m_FirstChild
End Property
Public Property Let FirstChild(ByVal vNewValue As Long)
m_FirstChild = vNewValue
If m_FirstChild > 0 Then
GetNode m_FirstChild, mCol
End If
End Property
Private Sub GetNode(vId As Long, mCol As Collection)
' получить данные о подчиненных узлах
Dim cn As clsNode
Dim xPrev As Long
Dim xNext As Long
Dim xLen As Long
Dim xFirst As Long
Dim xType As Long
Dim xStart As Long
Dim xText As String
Dim xSmall As Boolean
Dim i As Long
Dim x As Long
Dim iFile As Long
Dim dWord As DWORD_C
Dim sKey As String
If vId > 0 Then
' получаем абсолютный адрес блока
i = Root(vId)
' определяем длину заголовка
dWord.b1 = fileBuf(i + 64)
dWord.b2 = fileBuf(i + 65)
dWord.b3 = 0
dWord.b4 = 0
xLen = HDec(dWord)
If xLen > 0 Then
' если есть длина заголовка, считываем заголовок
' -3 - удаляем нулевой терминатор строки
xText = vbNullString
For x = 0 To xLen - 3 Step 2
xText = xText & Chr$(fileBuf(i + x))
Next
' определяем тип объекта
xType = fileBuf(i + 66)
' определяем предыдущий объект
dWord.b1 = fileBuf(i + 68)
dWord.b2 = fileBuf(i + 69)
dWord.b3 = fileBuf(i + 70)
dWord.b4 = fileBuf(i + 71)
xPrev = HDec(dWord)
' определяем сдедующий объект
dWord.b1 = fileBuf(i + 72)
dWord.b2 = fileBuf(i + 73)
dWord.b3 = fileBuf(i + 74)
dWord.b4 = fileBuf(i + 75)
xNext = HDec(dWord)
' определяем подчиненный объект
dWord.b1 = fileBuf(i + 76)
dWord.b2 = fileBuf(i + 77)
dWord.b3 = fileBuf(i + 78)
dWord.b4 = fileBuf(i + 79)
xFirst = HDec(dWord)
' определяем номер стартового блока в FAT
dWord.b1 = fileBuf(i + 116)
dWord.b2 = fileBuf(i + 117)
dWord.b3 = fileBuf(i + 118)
dWord.b4 = fileBuf(i + 119)
xStart = HDec(dWord)
' определяем размер объекта
dWord.b1 = fileBuf(i + 120)
dWord.b2 = fileBuf(i + 121)
dWord.b3 = fileBuf(i + 122)
dWord.b4 = fileBuf(i + 123)
xLen = HDec(dWord)
If xLen < 4096 Then
xSmall = True
Else
xSmall = False
End If
' записываем объект в колекцию
Set cn = New clsNode
cn.NodeName = xText
cn.NextID = xNext
cn.PrevID = xPrev
cn.NodeSize = xLen
cn.NodeType = xType
cn.SmallFat = xSmall
cn.FirstChild = xFirst
cn.StartNumber = xStart
cn.NodeID = vId
If xType = 2 Then
' что бы по значению ключа обозначить поток
sKey = "S" & Format$(vId, "00000000")
Else
sKey = "C" & Format$(vId, "00000000")
End If
cn.Key = sKey
mCol.Add cn, sKey
End If
Set cn = Nothing
' рекурсивно вызываем сами себя
If xPrev > 0 Then GetNode xPrev, mCol
If xNext > 0 Then GetNode xNext, mCol
End If
End Sub
Private Sub Class_Terminate()
Set mCol = Nothing
End Sub
|
В разделе деклараций нашего модуля (не класса!) объявим массив, который будет содержать
ссылки на абсолютные адреса объектов каталога, а так же объявим наш класс:
Public Root() As Long ' здесь коллекция объектов *.md файла
Public tv As clsNode ' сюда копируется структура файла
|
и напишем функцию, которая достанет из файла структуру каталога
Public Function GetRootTree() As Boolean
' создание дерева каталога
Dim i As Long
Dim x As Long
Dim y As Long
Dim j As Long
Dim iCount As Long
Dim iMax As Long
Dim dWord As DWORD_C
Dim rc As Boolean
rc = False
' определяем количество объектов каталога
x = HeaderMD.StartRoot
i = 1 + (HeaderMD.StartRoot + 1) * SECTORSIZE
iMax = 0
' организуем цикл , если абс.сектор>0
Do While i > 0
' всего в секторе четыре 128 байтных блоков
iMax = iMax + 4
' получаем значение следующего сектора
x = GetNextBigFATSector(x)
If x > 0 Then
i = fatBBD(x).Adres
Else
i = 0
End If
Loop
' определяем массив абс.адресов каталога
ReDim Root(0 To iMax)
x = HeaderMD.StartRoot
i = 1 + (HeaderMD.StartRoot + 1) * SECTORSIZE
iCount = 0
' организуем цикл , если абс.сектор>0
Do While i > 0
' всего в секторе два 128 байтных блоков
For j = 0 To 511 Step 128
' записываем абсолютный адрес в массив каталога
Root(iCount) = i + j
iCount = iCount + 1
Next
' получаем значение следующего сектора
x = GetNextBigFATSector(x)
If x > 0 Then
i = fatBBD(x).Adres
Else
i = 0
End If
Loop
' получаем абс.номер стартового сектора каталога
i = 1 + (HeaderMD.StartRoot + 1) * SECTORSIZE
' получаем абс.адрес слова, где указан первый потомок(+4CH)
i = i + 76
dWord.b1 = fileBuf(i)
dWord.b2 = fileBuf(i + 1)
dWord.b3 = fileBuf(i + 2)
dWord.b4 = fileBuf(i + 3)
x = HDec(dWord)
Set tv = New clsNode
tv.NodeName = mdFileName ' называем корень именем составного файла
tv.NodeID = 0
tv.FirstChild = x ' всю структуру определит сам класс
rc = True
myExit:
GetRootTree = rc
End Function
|
Теперь у нас есть структура каталога, оба FAT и, зная стартовый адрес любого объекта, можно
вытянуть из составного файла весь объект (не забывая, что исходя из размера объекта
надо использовать FAT больших или малых блоков). |
Партнеры:
Также может быть интересно:
Канал Россия 1 на http://spbtvonline.ru/
|