ps4_pkg_info/

lib.rs

use std::io::{self, Cursor, Read, Seek, SeekFrom};

use byteorder::{BigEndian, ReadBytesExt};
use hex;
use log;

// magic numbers
const SFO_TABLE_ID: u32 = 0x1000;
const ICON0_TABLE_ID: u32 = 0x1200;
const FILE_DESCRIPTOR: &[u8; 4] = b"\x7fCNT";

/// Get package information from a PS4 PKG file
/// 
/// # Arguments
///    * `file_buf` - A vector of bytes representing the PKG file
/// 
/// # Returns
///    * `PackageInfo` - A struct containing the package information
/// 
/// # Example
/// ```rust
/// use std::{fs::File, io::Read};
/// 
/// use ps4_pkg_info::get_pkg_info;
/// use env_logger;
/// 
/// const SIZE_1MB: usize = 0x100000;
/// 
/// fn main() -> std::io::Result<()> {
///   env_logger::init();
///   let mut file = File::open("tests/example.pkg")?;
///   let mut file_buffer: Vec<u8> = vec![0; SIZE_1MB]; // Read in 1MB of data
///   file.read(&mut file_buffer)?;
/// 
///  let pkg_info = get_pkg_info(&file_buffer)?;
///  log::info!("{:?}", pkg_info);
///  Ok(())
/// }
/// ```
pub fn get_pkg_info(file_buf: &Vec<u8>) -> io::Result<PackageInfo> {
    // let mut file = File::open("PS4_PKGI13337_v0.87.3.pkg")?;
    let mut file_cursor = Cursor::new(file_buf);
    let mut base_buf = vec![0; 0x1f];

    file_cursor.read(&mut base_buf)?;

    // read first 4 bytes into a buffer
    let cnt_buf = base_buf[..0x4].to_vec();
    // check if we have the magic number
    if cnt_buf != FILE_DESCRIPTOR {
        panic!("Invalid file format");
    }

    let table_total = u32::from_be_bytes(base_buf[0x10..0x14].try_into().unwrap());
    let table_offset = u32::from_be_bytes(base_buf[0x18..0x1c].try_into().unwrap());
    let table_size = table_total * 32;
    let mut table_buf = vec![0; table_size as usize];

    file_cursor.seek(SeekFrom::Start(table_offset as u64))?;
    file_cursor.read_exact(&mut table_buf)?;

    // init empty param_sfo as PkgTableEntry
    let mut param_sfo_table_entry = PkgTableEntry {
        id: 0,
        offset: 0,
        size: 0,
    };

    // TODO: IMPLEMENT ICON0.PNG
    // init empty icon0 as PkgTableEntry
    // let mut icon0_table_entry = PkgTableEntry {
    //     id: 0,
    //     offset: 0,
    //     size: 0,
    // };

    log::debug!("{} files found", table_total);

    // iterate through each table entry
    for i in 0..table_total {
        let slice = table_buf[(i * 32) as usize..((i * 32) + 32) as usize].to_vec();
        let pkg_table_entry = get_pkg_table_entry(slice);
        if pkg_table_entry.id == SFO_TABLE_ID {
            // we have found the sfo file_cursor.
            log::debug!("params.sfo found!");
            param_sfo_table_entry = pkg_table_entry.clone();
        }
        if pkg_table_entry.id == ICON0_TABLE_ID {
            // we have found the icon0 file_cursor.
            log::debug!("icon0.png found!");
            // TODO: IMPLEMENT ICON0.PNG
            // icon0_table_entry = pkg_table_entry.clone();
        }
    }

    // TODO: IMPLEMENT ICON0.PNG
    // // seek to the offset of the icon0.png file
    // file_cursor.seek(SeekFrom::Start(icon0_table_entry.offset as u64))?;
    // // create a buffer to hold the icon0.png file
    // let mut icon0_buf = vec![0; icon0_table_entry.size as usize];
    // // read the icon0.png file into a buffer
    // file_cursor.read_exact(&mut icon0_buf)?;
    // log::debug!("icon0.png size: {:?}", icon0_buf.len());

    // seek to the offset of the param.sfo file
    file_cursor.seek(SeekFrom::Start(param_sfo_table_entry.offset as u64))?;
    // create a buffer to hold the param.sfo file
    let mut param_sfo_buf = vec![0; param_sfo_table_entry.size as usize];
    // read the param.sfo file into a buffer
    file_cursor.read_exact(&mut param_sfo_buf)?;
    log::debug!("param.sfo size: {:?}", param_sfo_buf.len());

    let param_sfo_header = get_param_sfo_header(&param_sfo_buf);
    let param_sfo_labels = param_sfo_buf
        [param_sfo_header.label_ptr as usize..param_sfo_table_entry.size as usize]
        .to_vec();
    let param_sfo_data = param_sfo_buf
        [param_sfo_header.data_ptr as usize..param_sfo_table_entry.size as usize]
        .to_vec();

    let mut pkg_info = PackageInfo {
        app_type: PackageInfoAppType::Unknown,
        app_ver: "".to_string(),
        attribute: 0,
        category: Category::AdditionalContent,
        content_id: "".to_string(),
        download_data_size: 0,
        pubtoolinfo: "".to_string(),
        pubtoolver: 0,
        system_ver: 0,
        title: "".to_string(),
        title_id: "".to_string(),
        version: "".to_string(),
        // extra: HashMap::new(),
    };

    let mut section_offset = 20;
    let section_size = 16;

    for _i in 0..param_sfo_header.section_total {
        let param_sfo_section_buf =
            param_sfo_buf[section_offset as usize..section_offset + section_size].to_vec();
        let param_sfo_section = get_param_sfo_section(param_sfo_section_buf);

        let mut label_buf = Vec::new();

        // start reading each byte from label offset
        for &byte in param_sfo_labels[param_sfo_section.label_offset as usize..].iter() {
            if byte == 0 {
                break; // Stop reading when we encounter the target (stop) character, 0
            }
            label_buf.push(byte); // Otherwise, collect the byte
        }

        let label = String::from_utf8(label_buf).unwrap_or("".to_string());

        let value_str = match param_sfo_section.data_type {
            ParamSfoSectionDataType::String => {
                let value_buf = param_sfo_data[param_sfo_section.data_offset as usize
                    ..(param_sfo_section.data_offset + param_sfo_section.used_data_field) as usize]
                    .to_vec();
                String::from_utf8(value_buf).unwrap_or("".to_string())
            }
            ParamSfoSectionDataType::Integer => {
                let value_buf = param_sfo_data[param_sfo_section.data_offset as usize
                    ..(param_sfo_section.data_offset + param_sfo_section.used_data_field) as usize]
                    .to_vec();
                u32::from_le_bytes(value_buf[0..4].try_into().unwrap()).to_string()
            }
            _ => "".to_string(),
        };
        log::debug!("{}: {}", label, value_str);

        match label.as_str() {
            "APP_TYPE" => pkg_info.app_type = PackageInfoAppType::from(value_str.parse().unwrap_or(0)),
            "APP_VER" => pkg_info.app_ver = value_str,
            "ATTRIBUTE" => pkg_info.attribute = value_str.parse().unwrap_or(0),
            // "CATEGORY" => pkg_info.category = Category::from(value_str.as_str()),
            "CONTENT_ID" => pkg_info.content_id = value_str,
            "DOWNLOAD_DATA_SIZE" => pkg_info.download_data_size = value_str.parse().unwrap_or(0),
            "PUBTOOLINFO" => pkg_info.pubtoolinfo = value_str,
            "PUBTOOLVER" => pkg_info.pubtoolver = value_str.parse().unwrap_or(0),
            "SYSTEM_VER" => pkg_info.system_ver = value_str.parse().unwrap_or(0),
            "TITLE" => pkg_info.title = value_str,
            "TITLE_ID" => pkg_info.title_id = value_str,
            "VERSION" => pkg_info.version = value_str,
            &_ => {
                // pkg_info.extra.insert(label, value_str);
            }
        }
        section_offset += section_size;
    }

    Ok(pkg_info)
}

fn get_pkg_table_entry(slice: Vec<u8>) -> PkgTableEntry {
    let mut cursor = Cursor::new(slice);

    let values: Vec<u32> = (0..6)
        .map(|_| cursor.read_u32::<BigEndian>().unwrap())
        .collect();

    PkgTableEntry {
        id: values[0],
        offset: values[4],
        size: values[5],
    }
}

fn get_param_sfo_section(slice: Vec<u8>) -> ParamSfoSection {
    // Get the hexadecimal string representation of the byte slice (3rd to 4th byte)
    let data_type_hex_str = hex::encode(&slice[3..4]); // Slice the array to get the range (3, 4)

    // Parse the hex string to a number (u8, u16, u32, etc.)
    let data_type = u16::from_str_radix(&data_type_hex_str, 16).unwrap_or(0);

    ParamSfoSection {
        label_offset: u16::from_le_bytes(slice[0..2].try_into().unwrap()),
        data_type: ParamSfoSectionDataType::from_u16(data_type),
        used_data_field: u32::from_le_bytes(slice[4..8].try_into().unwrap()),
        data_offset: u32::from_le_bytes(slice[12..16].try_into().unwrap()),
    }
}
fn get_param_sfo_header(slice: &Vec<u8>) -> ParamSfoHeader {
    ParamSfoHeader {
        label_ptr: u32::from_le_bytes(slice[8..12].try_into().unwrap()),
        data_ptr: u32::from_le_bytes(slice[12..16].try_into().unwrap()),
        section_total: u32::from_le_bytes(slice[16..20].try_into().unwrap()),
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ParamSfoHeader {
    label_ptr: u32,
    data_ptr: u32,
    section_total: u32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PkgTableEntry {
    id: u32,
    offset: u32,
    size: u32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PackageInfoAppType {
    Unknown,
    PaidStandaloneFull,
    Upgradable,
    Demo,
    Freemium,
}

impl From<u8> for PackageInfoAppType {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::Unknown,
            1 => Self::PaidStandaloneFull,
            2 => Self::Upgradable,
            3 => Self::Demo,
            4 => Self::Freemium,
            _ => Self::Unknown,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Category {
    AdditionalContent,
    BluRayDisc,
    GameContent,
    GameDigital,
    SystemApp,
    BigApp,
    BGApp,
    MiniApp,
    VideoServiceWebApp,
    PSCloudBetaApp,
    PS2,
    GameApplicationPatch,
    BigAppPatch,
    BGAppPatch,
    MiniAppPatch,
    VideoServiceWebAppPatch,
    PSCloudBetaAppPatch,
    SaveData,
}

impl From<&str> for Category {
    fn from(value: &str) -> Self {
        match value {
            "ac" => Self::AdditionalContent,
            "bd" => Self::BluRayDisc,
            "gc" => Self::GameContent,
            "gd" => Self::GameDigital,
            "gda" => Self::SystemApp,
            "gdc" => Self::BigApp,
            "gdd" => Self::BGApp,
            "gde" => Self::MiniApp,
            "gdk" => Self::VideoServiceWebApp,
            "gdl" => Self::PSCloudBetaApp,
            "gdO" => Self::PS2,
            "gp" => Self::GameApplicationPatch,
            "gpc" => Self::BigAppPatch,
            "gpd" => Self::BGAppPatch,
            "gpe" => Self::MiniAppPatch,
            "gpk" => Self::VideoServiceWebAppPatch,
            "gpl" => Self::PSCloudBetaAppPatch,
            "sd" => Self::SaveData,
            _ => panic!("Unknown category"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PackageInfo {
    pub app_type: PackageInfoAppType,
    pub app_ver: String,
    pub attribute: u32,
    pub category: Category,
    pub content_id: String,
    pub download_data_size: u64,
    pub pubtoolinfo: String,
    pub pubtoolver: u32,
    pub system_ver: u32,
    pub title: String,
    pub title_id: String,
    pub version: String,
    // pub extra: HashMap<String, String>,
}

impl PackageInfo {
    pub fn from_buffer(buf: &Vec<u8>) -> Self {
        get_pkg_info(buf).unwrap()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ParamSfoSectionDataType {
    Binary,
    String,
    Integer,
}

impl ParamSfoSectionDataType {
    // Define a function to convert u16 to ParamSfoSectionDataType
    fn from_u16(value: u16) -> Self {
        match value {
            0 => Self::Binary,
            2 => Self::String,
            4 => Self::Integer,
            _ => panic!("Unknown category"),
            // _ => None,  // Return None if the value doesn't match any variant
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ParamSfoSection {
    label_offset: u16,
    data_type: ParamSfoSectionDataType,
    used_data_field: u32,
    data_offset: u32,
}