上一篇文章中我们解析了PS2存储卡的文件系统，这次直接实战，编写python代码导出指定的游戏存档。本篇文章完整代码可以访问：ps2mc-browser。
01 解析SuperBlock#
SuperBlock结构如下，大小为340字节：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| struct SuperBlock {
char magic[28];
char version[12];
uint16 page_size;
uint16 pages_per_cluster;
uint16 pages_per_block;
uint16 unknown; // ignore
uint32 clusters_per_card;
uint32 alloc_offset;
uint32 alloc_end;
uint32 rootdir_cluster;
uint32 backup_block1; // ignore
uint32 backup_block2; // ignore
uint32 unknown[2]; // ignore
uint32 ifc_list[32];
uint32 bad_block_list[32]; // ignore
byte card_type;
byte card_flags;
byte unknown; // ignore
byte unknown; // ignore
};
|
使用struct.unpack()解包：
1
| struct.Struct("<28s12sHHH2xLLLL4x4x8x128s128xbbxx").unpack(byte_val)
|
得到page_size和pages_per_cluster。
02 读取page和cluster#
根据公式计算page和cluster大小：
1
2
3
| self.spare_size = (self.page_size // 128) * 4 # 备用区域字节数
self.raw_page_size = self.page_size + self.spare_size # 算上备用区域的page字节数
self.cluster_size = self.page_size * self.pages_per_cluster # 簇字节数
|
读取page和cluster，spare area里的内容是被舍弃掉的：
1
2
3
4
5
6
7
8
9
10
| def read_page(self, n): # n为page编号
offset = self.raw_page_size * n
return self.byte_val[offset: offset + self.page_size]
def read_cluster(self, n): # n为cluster编号
page_index = n * self.pages_per_cluster
byte_buffer = bytearray()
for i in range(self.pages_per_cluster):
byte_buffer += self.read_page(page_index + i)
return bytes(byte_buffer)
|
03 构建FAT矩阵#
从上一篇文章知道FAT矩阵的构建方式如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| def __build_fat_matrix(self):
# 从ifc_list构建间接FAT
indirect_fat_matrix = self.__build_matrix(self.ifc_list)
# 间接FAT是个一维数组
indirect_fat_matrix = indirect_fat_matrix.reshape(indirect_fat_matrix.size)
# 排除掉0xFFFFFFFF这种未分配的
indirect_fat_matrix = [x for x in indirect_fat_matrix if x != Fat.UNALLOCATED]
# 从间接FAT构建直接FAT
fat_matrix = self.__build_matrix(indirect_fat_matrix)
return fat_matrix
def __build_matrix(self, cluster_list):
# 初始化矩阵
matrix = np.zeros((len(cluster_list), self.fat_per_cluster), np.uint32)
# 遍历cluster
for index, v in enumerate(cluster_list):
# 读出每个cluster的256个FAT
cluster_value = self.read_cluster(v)
cluster_value_unpacked = np.frombuffer(cluster_value, np.uint32)
for index0, v0 in enumerate(cluster_value_unpacked):
# 给矩阵赋值
matrix[index, index0] = v0
return matrix
# 给出簇编号n，找到其对应的FAT的值
def get_fat_value(self, n):
value = self.fat_matrix[(n // self.fat_per_cluster) % self.fat_per_cluster,
n % self.fat_per_cluster]
# 最高位为8代表正常使用的簇，其它值代表簇未分配，最高位为8时，取低31位的整形值
return value ^ Fat.ALLOCATED_BIT if value & Fat.ALLOCATED_BIT > 0 else value
|
04 条目数据结构#
条目是所有文件和目录的元数据，条目的数据结构如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
| struct Entry {
uint16 mode;
uint16 unknown; // ignore
uint32 length;
char created[8];
uint32 cluster;
uint32 dir_entry; // ignore
char modified[8];
uint32 attr; // ignore
char padding[28]; // ignore
char name[32];
char padding[416]; // ignore
};
|
使用struct.unpack()解包：
1
| struct.Struct("<H2xL8sL4x8s4x28x32s416x").unpack(byte_val)
|
每个条目的大小为512字节，条目里最重要的字段是cluster，标识了该条目对应的文件或目录的簇编号。如果本条目是目录，则对应的簇编号是“条目簇”；如果本条目是文件，则对应的簇编号是“文件簇”。另一个重要字段是length，如果本条目是目录，则对应的是目录下的条目数；如果本条目是文件，则对应的是文件的字节数。
05 解析“条目簇”和“数据簇”#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| # 读取条目，条目是512字节，一个簇可以包含多个条目
def read_entry_cluster(self, cluster_offset):
cluster_value = self.read_cluster(cluster_offset + self.alloc_offset)
return Entry.build(cluster_value)
# 读取数据，要从第一个簇开始读取到文件结束
def read_data_cluster(self, entry):
byte_buffer = bytearray()
chain_start = entry.cluster
bytes_read = 0
while chain_start != Fat.CHAIN_END:
to_read = min(entry.length - bytes_read, self.cluster_size)
byte_buffer += self.read_cluster(chain_start + self.alloc_offset)[:to_read]
bytes_read += to_read
chain_start = self.get_fat_value(chain_start)
return bytes(byte_buffer)
def build(byte_val):
entry_count = len(byte_val) // Entry.__size
entries = []
for i in range(entry_count):
entries.append(Entry(byte_val[i * Entry.__size:
i * Entry.__size + Entry.__size]))
return entries
|
06 读取存储卡中的所有文件#
上一篇文章说过，根目录没有条目，它的首个“条目簇”在超级块的rootdir_cluster中，它的“包含条目数”在.这个条目中。
要读取存储卡中的所有文件，第一步是解析根目录下所有条目，再解析条目下所有文件。因此只要循环调用以下方法：
1
2
3
4
5
6
7
8
9
10
| def find_sub_entries(self, parent_entry):
chain_start = parent_entry.cluster
sub_entries = []
while chain_start != Fat.CHAIN_END:
entries = self.read_entry_cluster(chain_start)
for e in entries:
if len(sub_entries) < parent_entry.length:
sub_entries.append(e.unpack())
chain_start = self.get_fat_value(chain_start)
return [x for x in sub_entries if not x.name.startswith('.')]
|
结果如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| BISCPS-15119sv01
GameData
BISCPS-15119sv01
icon00.ico
icon.sys
BISCPS-15116sv01
GameData
BISCPS-15116sv01
icon00.ico
icon.sys
BASLUS-21441DBZT2
icon.sys
dbzsn.ico
BASLUS-21441DBZT2
...
|
07 导出游戏存档#
既然所有文件条目都已经读取出来了，我们只要写个方法，根据输入的游戏名称，即可导出目录下的所有文件。
1
2
3
4
5
6
7
8
9
| def export(self, name, dest):
dir_path = dest + os.sep + name
if not os.path.exists(dir_path):
os.mkdir(dir_path)
entries = self.lookup_entry_by_name(name)
for e in entries:
if e.is_file():
with open(dir_path + os.sep + e.name, 'wb') as f:
f.write(self.ps2mc.read_data_cluster(e))
|
08 结尾#
至此，我们已经可以把一个游戏的存档从存储卡中导出来了。如果你有python运行环境，可以直接运行文章一开始提供的github链接里的代码。
下一篇我们将分析一下每个存档文件里的icon.sys和xxx.ico文件，这两个文件是存档3d特效的数据文件。
09 参考文献#