Dell_PFS_Extract.py

#!/usr/bin/env python3 -B
# coding=utf-8

"""
Dell PFS Extract
Dell PFS Update Extractor
Copyright (C) 2018-2024 Plato Mavropoulos
"""

import contextlib
import ctypes
import io
import lzma
import os
import zlib

from common.checksums import get_chk_8_xor
from common.comp_szip import is_szip_supported, szip_decompress
from common.num_ops import get_ordinal
from common.path_ops import del_dirs, get_path_files, make_dirs, path_name, path_parent, path_stem, safe_name
from common.patterns import PAT_DELL_FTR, PAT_DELL_HDR, PAT_DELL_PKG
from common.struct_ops import Char, get_struct, UInt8, UInt16, UInt32, UInt64
from common.system import printer
from common.templates import BIOSUtility
from common.text_ops import file_to_bytes

from AMI_PFAT_Extract import IntelBiosGuardHeader, parse_bg_script, parse_bg_sign, PFAT_INT_SIG_MAX_LEN

TITLE = 'Dell PFS Update Extractor v7.1'


class DellPfsHeader(ctypes.LittleEndianStructure):
    """ Dell PFS Header Structure """

    _pack_ = 1
    _fields_ = [
        ('Tag', Char * 8),  # 0x00
        ('HeaderVersion', UInt32),  # 0x08
        ('PayloadSize', UInt32),  # 0x0C
        # 0x10
    ]

    def struct_print(self, padd):
        """ Display structure information """

        printer(['Header Tag    :', self.Tag.decode('utf-8')], padd, False)
        printer(['Header Version:', self.HeaderVersion], padd, False)
        printer(['Payload Size  :', f'0x{self.PayloadSize:X}'], padd, False)


class DellPfsFooter(ctypes.LittleEndianStructure):
    """ Dell PFS Footer Structure """

    _pack_ = 1
    _fields_ = [
        ('PayloadSize', UInt32),  # 0x00
        ('Checksum', UInt32),  # 0x04 ~CRC32 w/ Vector 0
        ('Tag', Char * 8),  # 0x08
        # 0x10
    ]

    def struct_print(self, padd):
        """ Display structure information """

        printer(['Payload Size    :', f'0x{self.PayloadSize:X}'], padd, False)
        printer(['Payload Checksum:', f'0x{self.Checksum:08X}'], padd, False)
        printer(['Footer Tag      :', self.Tag.decode('utf-8')], padd, False)


class DellPfsEntryBase(ctypes.LittleEndianStructure):
    """ Dell PFS Entry Base Structure """

    _pack_ = 1
    _fields_ = [
        ('GUID', UInt32 * 4),  # 0x00 Little Endian
        ('HeaderVersion', UInt32),  # 0x10 1 or 2
        ('VersionType', UInt8 * 4),  # 0x14
        ('Version', UInt16 * 4),  # 0x18
        ('Reserved', UInt64),  # 0x20
        ('DataSize', UInt32),  # 0x28
        ('DataSigSize', UInt32),  # 0x2C
        ('DataMetSize', UInt32),  # 0x30
        ('DataMetSigSize', UInt32),  # 0x34
        # 0x38 (parent class, base)
    ]

    def struct_print(self, padd):
        """ Display structure information """

        guid = f'{int.from_bytes(self.GUID, "little"):0{0x10 * 2}X}'
        unknown = f'{int.from_bytes(self.Unknown, "little"):0{len(self.Unknown) * 8}X}'
        version = get_entry_ver(self.Version, self.VersionType)

        printer(['Entry GUID             :', guid], padd, False)
        printer(['Entry Version          :', self.HeaderVersion], padd, False)
        printer(['Payload Version        :', version], padd, False)
        printer(['Reserved               :', f'0x{self.Reserved:X}'], padd, False)
        printer(['Payload Data Size      :', f'0x{self.DataSize:X}'], padd, False)
        printer(['Payload Signature Size :', f'0x{self.DataSigSize:X}'], padd, False)
        printer(['Metadata Data Size     :', f'0x{self.DataMetSize:X}'], padd, False)
        printer(['Metadata Signature Size:', f'0x{self.DataMetSigSize:X}'], padd, False)
        printer(['Unknown                :', f'0x{unknown}'], padd, False)


class DellPfsEntryR1(DellPfsEntryBase):
    """ Dell PFS Entry Revision 1 Structure """

    _pack_ = 1
    _fields_ = [
        ('Unknown', UInt32 * 4),  # 0x38
        # 0x48 (child class, R1)
    ]


class DellPfsEntryR2(DellPfsEntryBase):
    """ Dell PFS Entry Revision 2 Structure """

    _pack_ = 1
    _fields_ = [
        ('Unknown', UInt32 * 8),  # 0x38
        # 0x58 (child class, R2)
    ]


class DellPfsInfo(ctypes.LittleEndianStructure):
    """ Dell PFS Information Header Structure """

    _pack_ = 1
    _fields_ = [
        ('HeaderVersion', UInt32),  # 0x00
        ('GUID', UInt32 * 4),  # 0x04 Little Endian
        # 0x14
    ]

    def struct_print(self, padd):
        """ Display structure information """

        guid = f'{int.from_bytes(self.GUID, "little"):0{0x10 * 2}X}'

        printer(['Info Version:', self.HeaderVersion], padd, False)
        printer(['Entry GUID  :', guid], padd, False)


class DellPfsName(ctypes.LittleEndianStructure):
    """ Dell PFS FileName Header Structure """

    _pack_ = 1
    _fields_ = [
        ('Version', UInt16 * 4),  # 0x00
        ('VersionType', UInt8 * 4),  # 0x08
        ('CharacterCount', UInt16),  # 0x0C UTF-16 2-byte Characters
        # 0x0E
    ]

    def struct_print(self, padd, name):
        """ Display structure information """

        version = get_entry_ver(self.Version, self.VersionType)

        printer(['Payload Version:', version], padd, False)
        printer(['Character Count:', self.CharacterCount], padd, False)
        printer(['Payload Name   :', name], padd, False)


class DellPfsMetadata(ctypes.LittleEndianStructure):
    """ Dell PFS Metadata Header Structure """

    _pack_ = 1
    _fields_ = [
        ('ModelIDs', Char * 501),  # 0x000
        ('FileName', Char * 100),  # 0x1F5
        ('FileVersion', Char * 33),  # 0x259
        ('Date', Char * 33),  # 0x27A
        ('Brand', Char * 80),  # 0x29B
        ('ModelFile', Char * 80),  # 0x2EB
        ('ModelName', Char * 100),  # 0x33B
        ('ModelVersion', Char * 33),  # 0x39F
        # 0x3C0
    ]

    def struct_print(self, padd):
        """ Display structure information """

        printer(['Model IDs    :', self.ModelIDs.decode('utf-8').removesuffix(',END')], padd, False)
        printer(['File Name    :', self.FileName.decode('utf-8')], padd, False)
        printer(['File Version :', self.FileVersion.decode('utf-8')], padd, False)
        printer(['Date         :', self.Date.decode('utf-8')], padd, False)
        printer(['Brand        :', self.Brand.decode('utf-8')], padd, False)
        printer(['Model File   :', self.ModelFile.decode('utf-8')], padd, False)
        printer(['Model Name   :', self.ModelName.decode('utf-8')], padd, False)
        printer(['Model Version:', self.ModelVersion.decode('utf-8')], padd, False)


class DellPfsPfatMetadata(ctypes.LittleEndianStructure):
    """ Dell PFS BIOS Guard Metadata Structure """

    _pack_ = 1
    _fields_ = [
        ('Address', UInt32),  # 0x00
        ('Unknown0', UInt32),  # 0x04
        ('Offset', UInt32),  # 0x08 Matches BG Script > I0
        ('DataSize', UInt32),  # 0x0C Matches BG Script > I2 & Header > Data Size
        ('Unknown1', UInt32),  # 0x10
        ('Unknown2', UInt32),  # 0x14
        ('Unknown3', UInt8),  # 0x18
        # 0x19
    ]

    def struct_print(self, padd):
        """ Display structure information """

        printer(['Address  :', f'0x{self.Address:X}'], padd, False)
        printer(['Unknown 0:', f'0x{self.Unknown0:X}'], padd, False)
        printer(['Offset   :', f'0x{self.Offset:X}'], padd, False)
        printer(['Length   :', f'0x{self.DataSize:X}'], padd, False)
        printer(['Unknown 1:', f'0x{self.Unknown1:X}'], padd, False)
        printer(['Unknown 2:', f'0x{self.Unknown2:X}'], padd, False)
        printer(['Unknown 3:', f'0x{self.Unknown3:X}'], padd, False)


def is_pfs_pkg(input_file):
    """
    The Dell ThinOS PKG update images usually contain multiple sections.
    Each section starts with a 0x30 header, which begins with pattern 72135500.
    The section length is found at 0x10-0x14 and its (optional) MD5 hash at 0x20-0x30.
    Section data can be raw or LZMA2 (7zXZ) compressed. The latter contains the PFS update image.
    """

    input_buffer = file_to_bytes(input_file)

    return PAT_DELL_PKG.search(input_buffer)


def is_pfs_hdr(input_file):
    """
    The Dell PFS update images usually contain multiple sections.
    Each section is zlib-compressed with header pattern ********++EEAA761BECBB20F1E651--789C,
    where ******** is the zlib stream size, ++ is the section type and -- the header Checksum XOR 8.
    The "Firmware" section has type AA and its files are stored in PFS format.
    The "Utility" section has type BB and its files are stored in PFS, BIN or 7z formats.
    """

    input_buffer = file_to_bytes(input_file)

    return bool(PAT_DELL_HDR.search(input_buffer))


def is_pfs_ftr(input_file):
    """
    Each section is followed by the footer pattern ********EEAAEE8F491BE8AE143790--,
    where ******** is the zlib stream size and ++ the footer Checksum XOR 8.
    """

    input_buffer = file_to_bytes(input_file)

    return bool(PAT_DELL_FTR.search(input_buffer))


def is_dell_pfs(input_file):
    """ Check if input is Dell PFS/PKG image """

    input_buffer = file_to_bytes(input_file)

    is_pkg = is_pfs_pkg(input_buffer)

    is_hdr = is_pfs_hdr(input_buffer)

    is_ftr = is_pfs_ftr(input_buffer)

    return bool(is_pkg or is_hdr and is_ftr)


def pfs_pkg_parse(input_file, extract_path, padding=0, structure=True, advanced=True):
    """ Parse & Extract Dell PFS Update image """

    input_buffer = file_to_bytes(input_file)

    make_dirs(extract_path, delete=True)

    is_dell_pkg = is_pfs_pkg(input_buffer)

    if is_dell_pkg:
        pfs_results = thinos_pkg_extract(input_buffer, extract_path)
    else:
        pfs_results = {path_stem(input_file) if os.path.isfile(input_file) else 'Image': input_buffer}

    # Parse each Dell PFS image contained in the input file
    for pfs_index, (pfs_name, pfs_buffer) in enumerate(pfs_results.items(), start=1):
        # At ThinOS PKG packages, multiple PFS images may be included in separate model-named folders
        pfs_path = os.path.join(extract_path, f'{pfs_index} {pfs_name}') if is_dell_pkg else extract_path

        # Parse each PFS ZLIB section
        for zlib_offset in get_section_offsets(pfs_buffer):
            # Call the PFS ZLIB section parser function
            pfs_section_parse(pfs_buffer, zlib_offset, pfs_path, pfs_name, pfs_index, 1, False,
                              padding, structure, advanced)


def thinos_pkg_extract(input_file, extract_path):
    """ Extract Dell ThinOS PKG 7zXZ """

    input_buffer = file_to_bytes(input_file)

    # Initialize PFS results (Name: Buffer)
    pfs_results = {}

    # Search input image for ThinOS PKG 7zXZ header
    thinos_pkg_match = PAT_DELL_PKG.search(input_buffer)

    lzma_len_off = thinos_pkg_match.start() + 0x10
    lzma_len_int = int.from_bytes(input_buffer[lzma_len_off:lzma_len_off + 0x4], 'little')
    lzma_bin_off = thinos_pkg_match.end() - 0x5

    lzma_bin_dat = input_buffer[lzma_bin_off:lzma_bin_off + lzma_len_int]

    # Check if the compressed 7zXZ stream is complete
    if len(lzma_bin_dat) != lzma_len_int:
        return pfs_results

    working_path = os.path.join(extract_path, 'THINOS_PKG_TEMP')

    make_dirs(working_path, delete=True)

    pkg_tar_path = os.path.join(working_path, 'THINOS_PKG.TAR')

    with open(pkg_tar_path, 'wb') as pkg_payload:
        pkg_payload.write(lzma.decompress(lzma_bin_dat))

    if is_szip_supported(pkg_tar_path, 0, args=['-tTAR'], check=True, silent=True):
        if szip_decompress(pkg_tar_path, working_path, 'TAR', 0, args=['-tTAR'], check=True, silent=True) == 0:
            os.remove(pkg_tar_path)
        else:
            return pfs_results
    else:
        return pfs_results

    for pkg_file in get_path_files(working_path):
        if is_pfs_hdr(pkg_file):
            pfs_name = path_name(path_parent(pkg_file))

            pfs_results.update({pfs_name: file_to_bytes(pkg_file)})

    del_dirs(working_path)

    return pfs_results


def get_section_offsets(buffer):
    """ Get PFS ZLIB Section Offsets """

    pfs_zlib_list = []  # Initialize PFS ZLIB offset list

    pfs_zlib_init = list(PAT_DELL_HDR.finditer(buffer))

    if not pfs_zlib_init:
        return pfs_zlib_list  # No PFS ZLIB detected

    # Remove duplicate/nested PFS ZLIB offsets
    for zlib_c in pfs_zlib_init:
        is_duplicate = False  # Initialize duplicate/nested PFS ZLIB offset

        for zlib_o in pfs_zlib_init:
            zlib_o_size = int.from_bytes(buffer[zlib_o.start() - 0x5:zlib_o.start() - 0x1], 'little')

            # If current PFS ZLIB offset is within another PFS ZLIB range (start-end), set as duplicate
            if zlib_o.start() < zlib_c.start() < zlib_o.start() + zlib_o_size:
                is_duplicate = True

        if not is_duplicate:
            pfs_zlib_list.append(zlib_c.start())

    return pfs_zlib_list


def pfs_section_parse(zlib_data, zlib_start, extract_path, pfs_name, pfs_index, pfs_count, is_rec,
                      padding=0, structure=True, advanced=True):
    """ Dell PFS ZLIB Section Parser """

    is_zlib_error = False  # Initialize PFS ZLIB-related error state

    section_type = zlib_data[zlib_start - 0x1]  # Byte before PFS ZLIB Section pattern is Section Type (e.g. AA, BB)

    section_name = {0xAA: 'Firmware', 0xBB: 'Utilities'}.get(section_type, f'Unknown ({section_type:02X})')

    # Show extraction complete message for each main PFS ZLIB Section
    printer(f'Extracting Dell PFS {pfs_index} > {pfs_name} > {section_name}', padding)

    # Set PFS ZLIB Section extraction sub-directory path
    section_path = os.path.join(extract_path, safe_name(section_name))

    # Create extraction sub-directory and delete old (if present, not in recursions)
    make_dirs(section_path, delete=(not is_rec), parents=True, exist_ok=True)

    # Store the compressed zlib stream start offset
    compressed_start = zlib_start + 0xB

    # Store the PFS ZLIB section header start offset
    header_start = zlib_start - 0x5

    # Store the PFS ZLIB section header contents (16 bytes)
    header_data = zlib_data[header_start:compressed_start]

    # Check if the PFS ZLIB section header Checksum XOR 8 is valid
    if get_chk_8_xor(header_data[:0xF]) != header_data[0xF]:
        printer('Error: Invalid Dell PFS ZLIB section Header Checksum!', padding)

        is_zlib_error = True

    # Store the compressed zlib stream size from the header contents
    compressed_size_hdr = int.from_bytes(header_data[:0x4], 'little')

    # Store the compressed zlib stream end offset
    compressed_end = compressed_start + compressed_size_hdr

    # Store the compressed zlib stream contents
    compressed_data = zlib_data[compressed_start:compressed_end]

    # Check if the compressed zlib stream is complete, based on header
    if len(compressed_data) != compressed_size_hdr:
        printer('Error: Incomplete Dell PFS ZLIB section data (Header)!', padding)

        is_zlib_error = True

    # Store the PFS ZLIB section footer contents (16 bytes)
    footer_data = zlib_data[compressed_end:compressed_end + 0x10]

    # Check if PFS ZLIB section footer was found in the section
    if not is_pfs_ftr(footer_data):
        printer('Error: This Dell PFS ZLIB section is corrupted!', padding)

        is_zlib_error = True

    # Check if the PFS ZLIB section footer Checksum XOR 8 is valid
    if get_chk_8_xor(footer_data[:0xF]) != footer_data[0xF]:
        printer('Error: Invalid Dell PFS ZLIB section Footer Checksum!', padding)

        is_zlib_error = True

    # Store the compressed zlib stream size from the footer contents
    compressed_size_ftr = int.from_bytes(footer_data[:0x4], 'little')

    # Check if the compressed zlib stream is complete, based on footer
    if compressed_size_ftr != compressed_size_hdr:
        printer('Error: Incomplete Dell PFS ZLIB section data (Footer)!', padding)

        is_zlib_error = True

    # Decompress PFS ZLIB section payload
    try:
        if is_zlib_error:
            raise ValueError('ZLIB_ERROR_OCCURED')  # ZLIB errors are critical

        section_data = zlib.decompress(compressed_data)  # ZLIB decompression
    except Exception as error:  # pylint: disable=broad-except
        printer(f'Error: Failed to decompress PFS ZLIB section: {error}!', padding)

        section_data = zlib_data  # Fallback to raw ZLIB data upon critical error

    # Call the PFS Extract function on the decompressed PFS ZLIB Section
    pfs_extract(section_data, pfs_index, pfs_name, pfs_count, section_path, padding, structure, advanced)


def pfs_extract(buffer, pfs_index, pfs_name, pfs_count, extract_path, padding=0, structure=True, advanced=True):
    """ Parse & Extract Dell PFS Volume """

    # Show PFS Volume indicator
    if structure:
        printer('PFS Volume:', padding)

    # Get PFS Header Structure values
    pfs_hdr = get_struct(buffer, 0, DellPfsHeader)

    # Validate that a PFS Header was parsed
    if pfs_hdr.Tag != b'PFS.HDR.':
        printer('Error: PFS Header could not be found!', padding + 4)

        return  # Critical error, abort

    # Show PFS Header Structure info
    if structure:
        printer('PFS Header:\n', padding + 4)

        pfs_hdr.struct_print(padding + 8)

    # Validate that a known PFS Header Version was encountered
    chk_hdr_ver(pfs_hdr.HeaderVersion, 'PFS', padding + 8)

    # Get PFS Payload Data
    pfs_payload = buffer[PFS_HEAD_LEN:PFS_HEAD_LEN + pfs_hdr.PayloadSize]

    # Parse all PFS Payload Entries/Components
    entry_index = 1  # Index number of each PFS Entry
    entry_start = 0  # Increasing PFS Entry starting offset
    entries_all = []  # Storage for each PFS Entry details
    filename_info = []  # Buffer for FileName Information Entry Data
    signature_info = []  # Buffer for Signature Information Entry Data

    pfs_entry_struct, pfs_entry_size = get_pfs_entry(pfs_payload, entry_start)  # Get PFS Entry Info

    while len(pfs_payload[entry_start:entry_start + pfs_entry_size]) == pfs_entry_size:
        # Analyze PFS Entry Structure and get relevant info
        _, entry_version, entry_guid, entry_data, entry_data_sig, entry_met, entry_met_sig, next_entry = \
            parse_pfs_entry(pfs_payload, entry_start, pfs_entry_size, pfs_entry_struct, 'PFS Entry', padding, structure)

        entry_type = 'OTHER'  # Adjusted later if PFS Entry is Zlib, PFAT, PFS Info, Model Info

        # Get PFS Information from the relevant (hardcoded) PFS Entry GUIDs
        if entry_guid in ['E0717CE3A9BB25824B9F0DC8FD041960', 'B033CB16EC9B45A14055F80E4D583FD3']:
            entry_type = 'NAME_INFO'

            filename_info = entry_data

        # Get Model Information from the relevant (hardcoded) PFS Entry GUID
        elif entry_guid == '6F1D619A22A6CB924FD4DA68233AE3FB':
            entry_type = 'MODEL_INFO'

        # Get Signature Information from the relevant (hardcoded) PFS Entry GUID
        elif entry_guid == 'D086AFEE3ADBAEA94D5CED583C880BB7':
            entry_type = 'SIG_INFO'

            signature_info = entry_data

        # Get Nested PFS from the relevant (hardcoded) PFS Entry GUID
        elif entry_guid == '900FAE60437F3AB14055F456AC9FDA84':
            entry_type = 'NESTED_PFS'  # Nested PFS are usually zlib-compressed so it might change to 'ZLIB' later

        # Store all relevant PFS Entry details
        entries_all.append([entry_index, entry_guid, entry_version, entry_type,
                            entry_data, entry_data_sig, entry_met, entry_met_sig])

        entry_index += 1  # Increase PFS Entry Index number for user-friendly output and name duplicates

        entry_start = next_entry  # Next PFS Entry starts after PFS Entry Metadata Signature

    # Parse all PFS Information Entries/Descriptors
    info_start = 0  # Increasing PFS Information Entry starting offset
    info_all = []  # Storage for each PFS Information Entry details

    while len(filename_info[info_start:info_start + PFS_INFO_LEN]) == PFS_INFO_LEN:
        # Get PFS Information Header Structure info
        filename_info_hdr = get_struct(filename_info, info_start, DellPfsInfo)

        # Show PFS Information Header Structure info
        if structure:
            printer('PFS Filename Information Header:\n', padding + 4)

            filename_info_hdr.struct_print(padding + 8)

        # Validate that a known PFS Information Header Version was encountered
        if filename_info_hdr.HeaderVersion != 1:
            printer(f'Error: Unknown PFS Filename Information Header Version {filename_info_hdr.HeaderVersion}!',
                    padding + 8)

            break  # Skip PFS Information Entries/Descriptors in case of unknown PFS Information Header Version

        # Get PFS Information Header GUID in Big Endian format, in order
        # to match each Info to the equivalent stored PFS Entry details.
        entry_guid = f'{int.from_bytes(filename_info_hdr.GUID, "little"):0{0x10 * 2}X}'

        # Get PFS FileName Structure values
        entry_info_mod = get_struct(filename_info, info_start + PFS_INFO_LEN, DellPfsName)

        # The PFS FileName Structure is not complete by itself. The size of the last field (Entry Name) is determined
        # from CharacterCount multiplied by 2 due to usage of UTF-16 2-byte Characters. Any Entry Name leading and/or
        # trailing space/null characters are stripped and Windows reserved/illegal filename characters are replaced.
        name_start = info_start + PFS_INFO_LEN + PFS_NAME_LEN  # PFS Entry's FileName start offset

        name_size = entry_info_mod.CharacterCount * 2  # PFS Entry's FileName buffer total size

        name_data = filename_info[name_start:name_start + name_size]  # PFS Entry's FileName buffer

        entry_name = safe_name(name_data.decode('utf-16').strip())  # PFS Entry's FileName value

        # Show PFS FileName Structure info
        if structure:
            printer('PFS FileName Entry:\n', padding + 8)

            entry_info_mod.struct_print(padding + 12, entry_name)

        # Get PFS FileName Version string via "Version" and "VersionType" fields
        # PFS FileName Version string must be preferred over PFS Entry's Version
        entry_version = get_entry_ver(entry_info_mod.Version, entry_info_mod.VersionType)

        # Store all relevant PFS FileName details
        info_all.append([entry_guid, entry_name, entry_version])

        # The next PFS Information Header starts after the calculated FileName size
        # Two space/null characters seem to always exist after each FileName value
        info_start += (PFS_INFO_LEN + PFS_NAME_LEN + name_size + 0x2)

    # Parse Nested PFS Metadata when its PFS Information Entry is missing
    for entry in entries_all:
        _, entry_guid, _, entry_type, _, _, entry_metadata, _ = entry

        if entry_type == 'NESTED_PFS' and not filename_info:
            # When PFS Information Entry exists, Nested PFS Metadata contains only Model IDs
            # When it's missing, the Metadata structure is large and contains equivalent info
            if len(entry_metadata) >= PFS_META_LEN:
                # Get Nested PFS Metadata Structure values
                entry_info = get_struct(entry_metadata, 0, DellPfsMetadata)

                # Show Nested PFS Metadata Structure info
                if structure:
                    printer('PFS Metadata Information:\n', padding + 4)

                    entry_info.struct_print(padding + 8)

                # As Nested PFS Entry Name, we'll use the actual PFS File Name
                # Replace common Windows reserved/illegal filename characters
                entry_name = safe_name(entry_info.FileName.decode('utf-8').removesuffix('.exe').removesuffix('.bin'))

                # As Nested PFS Entry Version, we'll use the actual PFS File Version
                entry_version = entry_info.FileVersion.decode('utf-8')

                # Store all relevant Nested PFS Metadata/Information details
                info_all.append([entry_guid, entry_name, entry_version])

                # Re-set Nested PFS Entry Version from Metadata
                entry[2] = entry_version

    # Parse all PFS Signature Entries/Descriptors
    sign_start = 0  # Increasing PFS Signature Entry starting offset

    while len(signature_info[sign_start:sign_start + PFS_INFO_LEN]) == PFS_INFO_LEN:
        # Get PFS Information Header Structure info
        signature_info_hdr = get_struct(signature_info, sign_start, DellPfsInfo)

        # Show PFS Information Header Structure info
        if structure:
            printer('PFS Signature Information Header:\n', padding + 4)

            signature_info_hdr.struct_print(padding + 8)

        # Validate that a known PFS Information Header Version was encountered
        if signature_info_hdr.HeaderVersion != 1:
            printer(f'Error: Unknown PFS Signature Information Header Version {signature_info_hdr.HeaderVersion}!',
                    padding + 8)

            break  # Skip PFS Signature Entries/Descriptors in case of unknown Header Version

        # PFS Signature Entries/Descriptors have DellPfsInfo + DellPfsEntryR* + Sign Size [0x2] + Sign Data [Sig Size]
        pfs_entry_struct, pfs_entry_size = get_pfs_entry(signature_info, sign_start + PFS_INFO_LEN)  # PFS Entry Info

        # Get PFS Entry Header Structure info
        entry_hdr = get_struct(signature_info, sign_start + PFS_INFO_LEN, pfs_entry_struct)

        # Show PFS Information Header Structure info
        if structure:
            printer('PFS Information Entry:\n', padding + 8)

            entry_hdr.struct_print(padding + 12)

        # Show PFS Signature Size & Data (after DellPfsEntryR*)
        sign_info_start = sign_start + PFS_INFO_LEN + pfs_entry_size

        sign_size = int.from_bytes(signature_info[sign_info_start:sign_info_start + 0x2], 'little')

        sign_data_raw = signature_info[sign_info_start + 0x2:sign_info_start + 0x2 + sign_size]

        sign_data_txt = f'{int.from_bytes(sign_data_raw, "little"):0{sign_size * 2}X}'

        if structure:
            printer('Signature Information:\n', padding + 8)

            printer(f'Signature Size: 0x{sign_size:X}', padding + 12, False)

            printer(f'Signature Data: {sign_data_txt[:32]} [...]', padding + 12, False)

        # The next PFS Signature Entry/Descriptor starts after the previous Signature Data
        sign_start += (PFS_INFO_LEN + pfs_entry_size + 0x2 + sign_size)

    # Parse each PFS Entry Data for special types (zlib or PFAT)
    for entry in entries_all:
        _, _, _, entry_type, entry_data, _, _, _ = entry

        # Very small PFS Entry Data cannot be of special type
        if len(entry_data) < PFS_HEAD_LEN:
            continue

        # Check if PFS Entry contains zlib-compressed sub-PFS Volume
        pfs_zlib_offsets = get_section_offsets(entry_data)

        # Check if PFS Entry contains sub-PFS Volume with PFAT Payload
        is_pfat = False  # Initial PFAT state for sub-PFS Entry

        _, pfat_entry_size = get_pfs_entry(entry_data, PFS_HEAD_LEN)  # Get possible PFS PFAT Entry Size

        pfat_hdr_off = PFS_HEAD_LEN + pfat_entry_size  # Possible PFAT Header starts after PFS Header & Entry

        pfat_entry_hdr = get_struct(entry_data, 0, DellPfsHeader)  # Possible PFS PFAT Entry

        if len(entry_data) - pfat_hdr_off >= PFAT_HDR_LEN:
            pfat_hdr = get_struct(entry_data, pfat_hdr_off, IntelBiosGuardHeader)

            is_pfat = pfat_hdr.get_platform_id().upper().startswith('DELL')

        # Parse PFS Entry which contains sub-PFS Volume with PFAT Payload
        if pfat_entry_hdr.Tag == b'PFS.HDR.' and is_pfat:
            entry_type = 'PFAT'  # Re-set PFS Entry Type from OTHER to PFAT, to use such info afterwards

            entry_data = parse_pfat_pfs(pfat_entry_hdr, entry_data, padding, structure)  # Parse sub-PFS PFAT Volume

        # Parse PFS Entry which contains zlib-compressed sub-PFS Volume
        elif pfs_zlib_offsets:
            entry_type = 'ZLIB'  # Re-set PFS Entry Type from OTHER to ZLIB, to use such info afterwards

            pfs_count += 1  # Increase the count/index of parsed main PFS structures by one

            # Parse each sub-PFS ZLIB Section
            for offset in pfs_zlib_offsets:
                # Get the Name of the zlib-compressed full PFS structure via the already stored PFS Information
                # The zlib-compressed full PFS structure(s) are used to contain multiple FW (CombineBiosNameX)
                # When zlib-compressed full PFS structure(s) exist within the main/first full PFS structure,
                # its PFS Information should contain their names (CombineBiosNameX). Since the main/first
                # full PFS structure has count/index 1, the rest start at 2+ and thus, their PFS Information
                # names can be retrieved in order by subtracting 2 from the main/first PFS Information values
                sub_pfs_name = f'{info_all[pfs_count - 2][1]} v{info_all[pfs_count - 2][2]}' if info_all else ' UNKNOWN'

                # Set the sub-PFS output path (create sub-folders for each sub-PFS and its ZLIB sections)
                sub_pfs_path = os.path.join(extract_path, f'{pfs_count} {safe_name(sub_pfs_name)}')

                # Recursively call the PFS ZLIB Section Parser function for the sub-PFS Volume (pfs_index = pfs_count)
                pfs_section_parse(entry_data, offset, sub_pfs_path, sub_pfs_name, pfs_count, pfs_count,
                                  True, padding + 4, structure, advanced)

        # Adjust PFS Entry Data after parsing PFAT (same ZLIB raw data, not stored afterwards)
        entry[4] = entry_data

        # Adjust PFS Entry Type from OTHER to PFAT or ZLIB (ZLIB is ignored at file extraction)
        entry[3] = entry_type

    # Name & Store each PFS Entry/Component Data, Data Signature, Metadata, Metadata Signature
    for entry in entries_all:
        file_index, file_guid, file_version, file_type, file_data, file_data_sig, file_meta, file_meta_sig = entry

        # Give Names to special PFS Entries, not covered by PFS Information
        if file_type == 'MODEL_INFO':
            file_name = 'Model Information'
        elif file_type == 'NAME_INFO':
            file_name = 'Filename Information'

            if not advanced:
                continue  # Don't store Filename Information in non-advanced user mode
        elif file_type == 'SIG_INFO':
            file_name = 'Signature Information'

            if not advanced:
                continue  # Don't store Signature Information in non-advanced user mode
        else:
            file_name = ''

        # Most PFS Entry Names & Versions are found at PFS Information via their GUID
        # Version can be found at DellPfsEntryR* but prefer PFS Information when possible
        for info in info_all:
            info_guid, info_name, info_version = info

            # Give proper Name & Version info if Entry/Information GUIDs match
            if info_guid == file_guid:
                file_name = info_name

                file_version = info_version

                # PFS with zlib-compressed sub-PFS use the same GUID
                info[0] = 'USED'

                # Break at 1st Name match to not rename again from
                # next zlib-compressed sub-PFS with the same GUID.
                break

        # For both advanced & non-advanced users, the goal is to store final/usable files only
        # so empty or intermediate files such as sub-PFS, PFS w/ PFAT or zlib-PFS are skipped
        # Main/First PFS CombineBiosNameX Metadata files must be kept for accurate Model Information
        # All users should check these files in order to choose the correct CombineBiosNameX modules
        write_files = []  # Initialize list of output PFS Entry files to be written/extracted

        is_zlib = bool(file_type == 'ZLIB')  # Determine if PFS Entry Data was zlib-compressed

        if file_data and not is_zlib:
            write_files.append([file_data, 'data'])  # PFS Entry Data Payload

        if file_data_sig and advanced:
            write_files.append([file_data_sig, 'sign_data'])  # PFS Entry Data Signature

        if file_meta and (is_zlib or advanced):
            write_files.append([file_meta, 'meta'])  # PFS Entry Metadata Payload

        if file_meta_sig and advanced:
            write_files.append([file_meta_sig, 'sign_meta'])  # PFS Entry Metadata Signature

        # Write/Extract PFS Entry files
        for file in write_files:
            full_name = f'{pfs_index} {pfs_name} -- {file_index} {file_name} v{file_version}'  # Full PFS Entry Name

            pfs_file_write(file[0], file[1], file_type, full_name, extract_path, padding, structure, advanced)

    # Get PFS Footer Data after PFS Header Payload
    pfs_footer = buffer[PFS_HEAD_LEN + pfs_hdr.PayloadSize:PFS_HEAD_LEN + pfs_hdr.PayloadSize + PFS_FOOT_LEN]

    # Analyze PFS Footer Structure
    chk_pfs_ftr(pfs_footer, pfs_payload, pfs_hdr.PayloadSize, 'PFS', padding, structure)


def parse_pfs_entry(entry_buffer, entry_start, entry_size, entry_struct, text, padding=0, structure=True):
    """ Analyze Dell PFS Entry Structure """

    # Get PFS Entry Structure values
    pfs_entry = get_struct(entry_buffer, entry_start, entry_struct)

    # Show PFS Entry Structure info
    if structure:
        printer('PFS Entry:\n', padding + 4)

        pfs_entry.struct_print(padding + 8)

    # Validate that a known PFS Entry Header Version was encountered
    chk_hdr_ver(pfs_entry.HeaderVersion, text, padding + 8)

    # Validate that the PFS Entry Reserved field is empty
    if pfs_entry.Reserved != 0:
        printer(f'Error: Detected non-empty {text} Reserved field!', padding + 8)

    # Get PFS Entry Version string via "Version" and "VersionType" fields
    entry_version = get_entry_ver(pfs_entry.Version, pfs_entry.VersionType)

    # Get PFS Entry GUID in Big Endian format
    entry_guid = f'{int.from_bytes(pfs_entry.GUID, "little"):0{0x10 * 2}X}'

    # PFS Entry Data starts after the PFS Entry Structure
    entry_data_start = entry_start + entry_size
    entry_data_end = entry_data_start + pfs_entry.DataSize

    # PFS Entry Data Signature starts after PFS Entry Data
    entry_data_sig_start = entry_data_end
    entry_data_sig_end = entry_data_sig_start + pfs_entry.DataSigSize

    # PFS Entry Metadata starts after PFS Entry Data Signature
    entry_met_start = entry_data_sig_end
    entry_met_end = entry_met_start + pfs_entry.DataMetSize

    # PFS Entry Metadata Signature starts after PFS Entry Metadata
    entry_met_sig_start = entry_met_end
    entry_met_sig_end = entry_met_sig_start + pfs_entry.DataMetSigSize

    entry_data = entry_buffer[entry_data_start:entry_data_end]  # Store PFS Entry Data

    entry_data_sig = entry_buffer[entry_data_sig_start:entry_data_sig_end]  # Store PFS Entry Data Signature

    entry_met = entry_buffer[entry_met_start:entry_met_end]  # Store PFS Entry Metadata

    entry_met_sig = entry_buffer[entry_met_sig_start:entry_met_sig_end]  # Store PFS Entry Metadata Signature

    return pfs_entry, entry_version, entry_guid, entry_data, entry_data_sig, entry_met, entry_met_sig, entry_met_sig_end


def parse_pfat_pfs(entry_hdr, entry_data, padding=0, structure=True):
    """ Parse Dell PFS Volume with PFAT Payload """

    # Show PFS Volume indicator
    if structure:
        printer('PFS Volume:', padding + 4)

    # Show sub-PFS Header Structure Info
    if structure:
        printer('PFS Header:\n', padding + 8)

        entry_hdr.struct_print(padding + 12)

    # Validate that a known sub-PFS Header Version was encountered
    chk_hdr_ver(entry_hdr.HeaderVersion, 'sub-PFS', padding + 12)

    # Get sub-PFS Payload Data
    pfat_payload = entry_data[PFS_HEAD_LEN:PFS_HEAD_LEN + entry_hdr.PayloadSize]

    # Get sub-PFS Footer Data after sub-PFS Header Payload, which must
    # must be retrieved at the initial entry_data, before PFAT parsing.
    pfat_footer = entry_data[PFS_HEAD_LEN + entry_hdr.PayloadSize:PFS_HEAD_LEN + entry_hdr.PayloadSize + PFS_FOOT_LEN]

    # Parse all sub-PFS Payload PFAT Entries
    pfat_entries_all = []  # Storage for all sub-PFS PFAT Entries Order/Offset & Payload/Raw Data
    pfat_entry_start = 0  # Increasing sub-PFS PFAT Entry start offset
    pfat_entry_index = 1  # Increasing sub-PFS PFAT Entry count index

    _, pfs_entry_size = get_pfs_entry(pfat_payload, 0)  # Get initial PFS PFAT Entry Size for loop

    while len(pfat_payload[pfat_entry_start:pfat_entry_start + pfs_entry_size]) == pfs_entry_size:
        # Get sub-PFS PFAT Entry Structure & Size info
        pfat_entry_struct, pfat_entry_size = get_pfs_entry(pfat_payload, pfat_entry_start)

        # Analyze sub-PFS PFAT Entry Structure and get relevant info
        pfat_entry, _, _, pfat_entry_data, _, pfat_entry_met, _, pfat_next_entry = \
            parse_pfs_entry(pfat_payload, pfat_entry_start, pfat_entry_size, pfat_entry_struct,
                            'sub-PFS PFAT Entry', padding + 4, structure)

        # Each sub-PFS PFAT Entry includes an AMI BIOS Guard (a.k.a. PFAT) block at the beginning
        # We need to parse the PFAT block and remove its contents from the final Payload/Raw Data
        pfat_hdr_off = pfat_entry_start + pfat_entry_size  # PFAT block starts after PFS Entry

        # Get sub-PFS PFAT Header Structure values
        pfat_hdr = get_struct(pfat_payload, pfat_hdr_off, IntelBiosGuardHeader)

        # Get ordinal value of the sub-PFS PFAT Entry Index
        pfat_entry_idx_ord = get_ordinal(pfat_entry_index)

        # Show sub-PFS PFAT Header Structure info
        if structure:
            printer(f'PFAT Block {pfat_entry_idx_ord} - Header:\n', padding + 12)

            pfat_hdr.struct_print(padding + 16)

        pfat_script_start = pfat_hdr_off + PFAT_HDR_LEN  # PFAT Block Script Start

        pfat_script_end = pfat_script_start + pfat_hdr.ScriptSize  # PFAT Block Script End

        pfat_script_data = pfat_payload[pfat_script_start:pfat_script_end]  # PFAT Block Script Data

        pfat_payload_start = pfat_script_end  # PFAT Block Payload Start (at Script end)

        pfat_payload_end = pfat_script_end + pfat_hdr.DataSize  # PFAT Block Data End

        pfat_payload_data = pfat_payload[pfat_payload_start:pfat_payload_end]  # PFAT Block Raw Data

        pfat_hdr_bgs_size = PFAT_HDR_LEN + pfat_hdr.ScriptSize  # PFAT Block Header & Script Size

        # The PFAT Script End should match the total Entry Data Size w/o PFAT block
        if pfat_hdr_bgs_size != pfat_entry.DataSize - pfat_hdr.DataSize:
            printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Header & PFAT Size mismatch!',
                    padding + 16)

        # Get PFAT Header Flags (SFAM, ProtectEC, GFXMitDis, FTU, Reserved)
        is_sfam, _, _, _, _ = pfat_hdr.get_flags()

        # Parse sub-PFS PFAT Signature, if applicable (only when PFAT Header > SFAM flag is set)
        if is_sfam:
            if structure:
                printer(f'PFAT Block {pfat_entry_idx_ord} - Signature:\n', padding + 12)

            # Get sub-PFS PFAT Signature length from Header pattern (not needed for Dell PFS)
            _pfat_sign_len = pfat_payload.find(pfat_hdr.get_hdr_marker(), pfat_payload_end,
                                               pfat_payload_end + PFAT_INT_SIG_MAX_LEN) - pfat_payload_end

            # Get sub-PFS PFAT Signature Structure values
            pfat_sign_len = parse_bg_sign(pfat_payload, pfat_payload_end, _pfat_sign_len, structure, padding + 16)

            if len(pfat_payload[pfat_payload_end:pfat_payload_end + pfat_sign_len]) != pfat_sign_len:
                printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Signature Size mismatch!',
                        padding + 12)

        # Show PFAT Script via BIOS Guard Script Tool
        if structure:
            printer(f'PFAT Block {pfat_entry_idx_ord} - Script:\n', padding + 12)

            _ = parse_bg_script(pfat_script_data, padding + 16)

        # The payload of sub-PFS PFAT Entries is not in proper order by default
        # We can get each payload's order from PFAT Script > OpCode #2 (set I0 imm)
        # PFAT Script OpCode #2 > Operand #3 stores the payload Offset in final image
        pfat_entry_off = int.from_bytes(pfat_script_data[0xC:0x10], 'little')

        # We can get each payload's length from PFAT Script > OpCode #4 (set I2 imm)
        # PFAT Script OpCode #4 > Operand #3 stores the payload Length in final image
        pfat_entry_len = int.from_bytes(pfat_script_data[0x1C:0x20], 'little')

        # Check that the PFAT Entry Length from Header & Script match
        if pfat_hdr.DataSize != pfat_entry_len:
            printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Header & Script Size mismatch!',
                    padding + 12)

        # Initialize sub-PFS PFAT Entry Metadata Address
        pfat_entry_adr = pfat_entry_off

        # Parse sub-PFS PFAT Entry/Block Metadata
        if len(pfat_entry_met) >= PFS_PFAT_LEN:
            # Get sub-PFS PFAT Metadata Structure values
            pfat_met = get_struct(pfat_entry_met, 0, DellPfsPfatMetadata)

            # Store sub-PFS PFAT Entry Metadata Address
            pfat_entry_adr = pfat_met.Address

            # Show sub-PFS PFAT Metadata Structure info
            if structure:
                printer(f'PFAT Block {pfat_entry_idx_ord} - Metadata:\n', padding + 12)

                pfat_met.struct_print(padding + 16)

            # Another way to get each PFAT Entry Offset is from its Metadata, if applicable
            # Check that the PFAT Entry Offsets from PFAT Script and PFAT Metadata match
            if pfat_entry_off != pfat_met.Offset:
                printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Metadata & PFAT Offset mismatch!',
                        padding + 16)

                # Prefer Offset from Metadata, in case PFAT Script differs
                pfat_entry_off = pfat_met.Offset

            # Another way to get each PFAT Entry Length is from its Metadata, if applicable
            # Check that the PFAT Entry Length from PFAT Script and PFAT Metadata match
            if not pfat_hdr.DataSize == pfat_entry_len == pfat_met.DataSize:
                printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Metadata & PFAT Length mismatch!',
                        padding + 16)

            # Check that the PFAT Entry payload Size from PFAT Header matches the one from PFAT Metadata
            if pfat_hdr.DataSize != pfat_met.DataSize:
                printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} Metadata & PFAT Block Size mismatch!',
                        padding + 16)

        # Get sub-PFS Entry Raw Data by subtracting PFAT Header & Script from PFAT Entry Data
        pfat_entry_data_raw = pfat_entry_data[pfat_hdr_bgs_size:]

        # The sub-PFS Entry Raw Data (w/o PFAT Header & Script) should match with the PFAT Block payload
        if pfat_entry_data_raw != pfat_payload_data:
            printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} w/o PFAT & PFAT Block Data mismatch!',
                    padding + 16)

            # Prefer Data from PFAT Block, in case PFAT Entry differs
            pfat_entry_data_raw = pfat_payload_data

        # Store each sub-PFS PFAT Entry/Block Offset, Address, Ordinal Index and Payload/Raw Data
        # Goal is to sort these based on Offset first and Address second, in cases of same Offset
        # For example, Precision 3430 has two PFAT Entries with the same Offset of 0x40000 at both
        # BG Script and PFAT Metadata but their PFAT Metadata Address is 0xFF040000 and 0xFFA40000
        pfat_entries_all.append((pfat_entry_off, pfat_entry_adr, pfat_entry_idx_ord, pfat_entry_data_raw))

        # Check if next sub-PFS PFAT Entry offset is valid
        if pfat_next_entry <= 0:
            printer(f'Error: Detected sub-PFS PFAT Block {pfat_entry_idx_ord} with invalid next PFAT Block offset!',
                    padding + 16)

            # Avoid a potential infinite loop if next sub-PFS PFAT Entry offset is bad
            pfat_next_entry += pfs_entry_size

        # Next sub-PFS PFAT Entry starts after sub-PFS Entry Metadata Signature
        pfat_entry_start = pfat_next_entry

        pfat_entry_index += 1

    # Sort all sub-PFS PFAT Entries based on their Offset/Address
    pfat_entries_all.sort()

    block_start_exp = 0  # Initialize sub-PFS PFAT Entry expected Offset
    total_pfat_data = b''  # Initialize final/ordered sub-PFS Entry Data

    # Parse all sorted sub-PFS PFAT Entries and merge their payload/data
    for block_start, _, block_index, block_data in pfat_entries_all:
        # Fill any data gaps between sorted sub-PFS PFAT Entries with padding
        # For example, Precision 7960 v0.16.68 has gap at 0x1190000-0x11A0000
        block_data_gap = block_start - block_start_exp

        if block_data_gap > 0:
            printer(f'Warning: Filled sub-PFS PFAT {block_index} data gap 0x{block_data_gap:X} '
                    f'[0x{block_start_exp:X}-0x{block_start:X}]!', padding + 8)

            # Use 0xFF padding to fill in data gaps in PFAT UEFI firmware images
            total_pfat_data += b'\xFF' * block_data_gap

        total_pfat_data += block_data  # Append sorted sub-PFS PFAT Entry payload/data

        block_start_exp = len(total_pfat_data)  # Set next sub-PFS PFAT Entry expected Start

    # Verify that the end offset of the last PFAT Entry matches the final sub-PFS Entry Data Size
    if len(total_pfat_data) != pfat_entries_all[-1][0] + len(pfat_entries_all[-1][3]):
        printer('Error: Detected sub-PFS PFAT total buffer size and last block end mismatch!', padding + 8)

    # Analyze sub-PFS Footer Structure
    chk_pfs_ftr(pfat_footer, pfat_payload, entry_hdr.PayloadSize, 'Sub-PFS', padding + 4, structure)

    return total_pfat_data


def get_pfs_entry(buffer, offset):
    """ Get Dell PFS Entry Structure & Size via its Version """

    pfs_entry_ver = int.from_bytes(buffer[offset + 0x10:offset + 0x14], 'little')  # PFS Entry Version

    if pfs_entry_ver == 1:
        return DellPfsEntryR1, ctypes.sizeof(DellPfsEntryR1)

    if pfs_entry_ver == 2:
        return DellPfsEntryR2, ctypes.sizeof(DellPfsEntryR2)

    return DellPfsEntryR2, ctypes.sizeof(DellPfsEntryR2)


def get_entry_ver(version_fields, version_types):
    """ Determine Dell PFS Entry Version string """

    version = ''  # Initialize Version string

    # Version Type (1 byte) determines the type of Version Value (2 bytes)
    # Version Type 'N' is Number, 'A' is Text and ' ' is Empty/Unused
    for index, field in enumerate(version_fields):
        eol = '' if index == len(version_fields) - 1 else '.'

        if version_types[index] == 65:
            version += f'{field:X}{eol}'  # 0x41 = ASCII
        elif version_types[index] == 78:
            version += f'{field:d}{eol}'  # 0x4E = Number
        elif version_types[index] in (0, 32):
            version = version.strip('.')  # 0x00 or 0x20 = Unused
        else:
            version += f'{field:X}{eol}'  # Unknown

    return version


def chk_hdr_ver(version, text, padding=0):
    """ Check if Dell PFS Header Version is known """

    if version in (1, 2):
        return

    printer(f'Error: Unknown {text} Header Version {version}!', padding)

    return


def chk_pfs_ftr(footer_buffer, data_buffer, data_size, text, padding=0, structure=True):
    """ Analyze Dell PFS Footer Structure """

    # Get PFS Footer Structure values
    pfs_ftr = get_struct(footer_buffer, 0, DellPfsFooter)

    # Validate that a PFS Footer was parsed
    if pfs_ftr.Tag == b'PFS.FTR.':
        # Show PFS Footer Structure info
        if structure:
            printer('PFS Footer:\n', padding + 4)

            pfs_ftr.struct_print(padding + 8)
    else:
        printer(f'Error: {text} Footer could not be found!', padding + 4)

    # Validate that PFS Header Payload Size matches the one at PFS Footer
    if data_size != pfs_ftr.PayloadSize:
        printer(f'Error: {text} Header & Footer Payload Size mismatch!', padding + 4)

    # Calculate the PFS Payload Data CRC-32 w/ Vector 0
    pfs_ftr_crc = ~zlib.crc32(data_buffer, 0) & 0xFFFFFFFF

    # Validate PFS Payload Data Checksum via PFS Footer
    if pfs_ftr.Checksum != pfs_ftr_crc:
        printer(f'Error: Invalid {text} Footer Payload Checksum!', padding + 4)


def pfs_file_write(bin_buff, bin_name, bin_type, full_name, out_path, padding=0, structure=True, advanced=True):
    """ Write/Extract Dell PFS Entry Files (Data, Metadata, Signature) """

    # Store Data/Metadata Signature (advanced users only)
    if bin_name.startswith('sign'):
        final_name = f'{safe_name(full_name)}.{bin_name.split("_")[1]}.sig'

        final_path = os.path.join(out_path, final_name)

        with open(final_path, 'wb') as pfs_out:
            pfs_out.write(bin_buff)  # Write final Data/Metadata Signature

        return  # Skip further processing for Signatures

    # Store Data/Metadata Payload
    bin_ext = f'.{bin_name}.bin' if advanced else '.bin'  # Simpler Data/Metadata Extension for non-advanced users

    # Some Data may be Text or XML files with useful information for non-advanced users
    is_text, final_data, file_ext, write_mode = \
        bin_is_text(bin_buff, bin_type, bin_name == 'meta', padding, structure, advanced)

    final_name = f'{safe_name(full_name)}{bin_ext[:-4] + file_ext if is_text else bin_ext}'

    final_path = os.path.join(out_path, final_name)

    with open(final_path, write_mode) as pfs_out:
        pfs_out.write(final_data)  # Write final Data/Metadata Payload


def bin_is_text(buffer, file_type, is_metadata, padding=0, structure=True, advanced=True):
    """ Check if Dell PFS Entry file/data is Text/XML and Convert """

    is_text = False
    write_mode = 'wb'
    extension = '.bin'
    buffer_in = buffer

    if b',END' in buffer[-0x8:]:  # Text Type 1
        is_text = True
        write_mode = 'w'
        extension = '.txt'

        buffer = buffer.decode('utf-8').split(',END')[0].replace(';', '\n')
    elif buffer.startswith(b'VendorName=Dell'):  # Text Type 2
        is_text = True
        write_mode = 'w'
        extension = '.txt'

        buffer = buffer.split(b'\x00')[0].decode('utf-8').replace(';', '\n')
    elif b'<Rimm x-schema="' in buffer[:0x50]:  # XML Type
        is_text = True
        write_mode = 'w'
        extension = '.xml'

        buffer = buffer.decode('utf-8')
    elif file_type in ('NESTED_PFS', 'ZLIB') and is_metadata and len(buffer) == PFS_META_LEN:  # Text Type 3
        is_text = True
        write_mode = 'w'
        extension = '.txt'

        with io.StringIO() as text_buffer, contextlib.redirect_stdout(text_buffer):
            get_struct(buffer, 0, DellPfsMetadata).struct_print(0)

            buffer = text_buffer.getvalue()

    # Show Model/PCR XML Information, if applicable
    if structure and is_text and not is_metadata:  # Metadata is shown at initial DellPfsMetadata analysis
        printer(f'PFS { {".txt": "Model", ".xml": "PCR XML"}[extension] } Information:\n', padding + 8)

        _ = [printer(line.strip('\r'), padding + 12, False) for line in buffer.split('\n') if line]

    # Only for non-advanced users due to signature (.sig) invalidation
    if advanced:
        return False, buffer_in, '.bin', 'wb'

    return is_text, buffer, extension, write_mode


# Get ctypes Structure Sizes
PFS_HEAD_LEN = ctypes.sizeof(DellPfsHeader)
PFS_FOOT_LEN = ctypes.sizeof(DellPfsFooter)
PFS_INFO_LEN = ctypes.sizeof(DellPfsInfo)
PFS_NAME_LEN = ctypes.sizeof(DellPfsName)
PFS_META_LEN = ctypes.sizeof(DellPfsMetadata)
PFS_PFAT_LEN = ctypes.sizeof(DellPfsPfatMetadata)
PFAT_HDR_LEN = ctypes.sizeof(IntelBiosGuardHeader)

if __name__ == '__main__':
    utility_args = [
        (['-a', '--advanced'], {'help': 'extract signatures and metadata', 'action': 'store_true'}),
        (['-s', '--structure'], {'help': 'show PFS structure information', 'action': 'store_true'})
    ]

    utility = BIOSUtility(title=TITLE, check=is_dell_pfs, main=pfs_pkg_parse, args=utility_args)

    utility.run_utility()