Innospect

https://docs.rs/innospect
Admin
Innospect is a Rust crate that provides typed access to the internal structures of an Inno Setup...
Tokens:771,470
Snippets:7,171
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example: Dump Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/header/struct.SetupHeader.html?search=u32+-%3E+bool

This example demonstrates how to read an Inno Setup installer file, parse its components including the version, offset table, setup-0 data, and setup header, and print detailed information.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview),);
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
        println!("  ini_entries:      {}", counts.ini_entries);
    }
}
```

--------------------------------

### Example: Dumping Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/version/struct.Version.html?search=std%3A%3Avec

This example demonstrates how to read an Inno Setup installer file, parse its version information, and print details such as the marker string, version components, flags, and variant.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview));
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
    }
}
```

--------------------------------

### Example: Dumping Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/version/struct.Version.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to read an Inno Setup installer file, parse its version information, and print various details including the marker, version components, flags, and variant.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview),);
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
    }
}
```

--------------------------------

### Example: Dump Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=u32+-%3E+bool

This example demonstrates how to read an Inno Setup installer file, parse it using `InnoInstaller::from_bytes`, and print various identification and offset table details. It handles file reading and parsing errors.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview));
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
    }
}
```

--------------------------------

### Parse and Inspect an Inno Setup Installer

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=u32+-%3E+bool

This example demonstrates how to read an Inno Setup installer file from disk, parse it using `innospect`, and then print various details about the installer, including version, flags, compression, and header information. It also shows how to access entry counts for different installer sections.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview),);
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
        println!("  ini_entries:      {}", counts.ini_entries);
        println!("  registry:         {}", counts.registry);
        println!("  install_deletes:  {}", counts.install_deletes);
        println!("  uninstall_deletes":{}", counts.uninstall_deletes,);
        println!("  run:              {}", counts.run);
        println!("  uninstall_run:    {}", counts.uninstall_run);

        let license_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::LicenseText))
            .map_or(0, <[u8]>::len);
        let info_before_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoBeforeText))
            .map_or(0, <[u8]>::len);
        let info_after_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoAfterText))
    }
}

```

--------------------------------

### Basic Inno Setup Installer Dump Example

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=

A minimal example demonstrating how to use the dump utility with a setup.exe file. Requires the setup.exe path as a command-line argument.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };
    // ... rest of the dump logic would follow here
```

--------------------------------

### Dump Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=

This example demonstrates how to read an Inno Setup installer file, parse it using `InnoInstaller::from_bytes`, and print detailed information about its identification, offset table, setup-0 data, and header.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview),);
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
        println!("  ini_entries:      {}", counts.ini_entries);
        println!("  registry:         {}", counts.registry);
        println!("  install_deletes:  {}", counts.install_deletes);
        println!("  uninstall_deletes":{}", counts.uninstall_deletes,);
        println!("  run:              {}", counts.run);
        println!("  uninstall_run:    {}", counts.uninstall_run);

        let license_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::LicenseText))
            .map_or(0, <[u8]>::len);
        let info_before_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoBeforeText))
            .map_or(0, <[u8]>::len);
        let info_after_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoAfterText))
            .map_or(0, <[u8]>::len);
        let compiled_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::CompiledCodeText))
            .map_or(0, <[u8]>::len);
        println!();
        println!("== Embedded blobs ==");
    }
}

```

--------------------------------

### Dump Inno Setup Installer Information

Source: https://docs.rs/innospect/latest/innospect/header/struct.SetupHeader.html?search=u32+-%3E+bool

This example demonstrates how to read an Inno Setup installer file, parse its data, and print various details including version, flags, offset table, setup header information, and entry counts. It utilizes the `InnoInstaller::from_bytes` method for parsing and accesses various fields of the installer and its header.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview));
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
        println!("  ini_entries:      {}", counts.ini_entries);
        println!("  registry:         {}", counts.registry);
        println!("  install_deletes:  {}", counts.install_deletes);
        println!("  uninstall_deletes":{}", counts.uninstall_deletes,);
        println!("  run:              {}", counts.run);
        println!("  uninstall_run:    {}", counts.uninstall_run);

        let license_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::LicenseText))
            .map_or(0, <[u8]>::len);
        let info_before_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoBeforeText))
            .map_or(0, <[u8]>::len);
        let info_after_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoAfterText))
            .map_or(0, <[u8]>::len);
    }
}
```

--------------------------------

### Parse Inno Setup Installer and Access Metadata

Source: https://docs.rs/innospect/latest/innospect/records/language/struct.LanguageEntry.html?search=std%3A%3Avec

This example demonstrates how to read an Inno Setup installer file, parse it using `InnoInstaller::from_bytes`, and access various metadata such as version information, offset table, header details, and entry counts. It also shows how to decompress the setup data and preview its content.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview),);
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
        println!(
            "  DefaultDirName: {:?}",
            header.default_dir_name().unwrap_or(""),
        );

        let counts = header.counts();
        println!();
        println!("== Entry counts ==");
        println!("  languages:        {}", counts.languages);
        println!("  custom_messages:  {}", counts.custom_messages);
        println!("  permissions:      {}", counts.permissions);
        println!("  types:            {}", counts.types);
        println!("  components:       {}", counts.components);
        println!("  tasks:            {}", counts.tasks);
        println!("  directories:      {}", counts.directories);
        if let Some(n) = counts.iss_sig_keys {
            println!("  iss_sig_keys:     {n}");
        }
        println!("  files:            {}", counts.files);
        println!("  file_locations:   {}", counts.file_locations);
        println!("  icons:            {}", counts.icons);
        println!("  ini_entries:      {}", counts.ini_entries);
        println!("  registry:         {}", counts.registry);
        println!("  install_deletes:  {}", counts.install_deletes);
        println!("  uninstall_deletes":{}", counts.uninstall_deletes,);
        println!("  run:              {}", counts.run);
        println!("  uninstall_run:    {}", counts.uninstall_run,);

        let license_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::LicenseText))
            .map_or(0, <[u8]>::len);
        let info_before_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoBeforeText))
            .map_or(0, <[u8]>::len);
        let info_after_len = installer
            .header()
            .and_then(|h| h.ansi(innospect::HeaderAnsi::InfoAfterText))
            .map_or(0, <[u8]>::len);
        let compiled_len = installer

```

--------------------------------

### Dump Installer Metadata

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=

This example demonstrates how to parse an Inno Setup installer from bytes and print various metadata including version, flags, offset table details, compression, encryption, and a preview of decompressed setup data.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size,);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();

```

--------------------------------

### Dump Installer Information

Source: https://docs.rs/innospect/latest/innospect/installer/struct.InnoInstaller.html?search=u32+-%3E+bool

This example demonstrates how to read an Inno Setup installer file, parse it using InnoInstaller, and print various details about its contents, including version, flags, offset table, setup header, and extracted file information.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: dump <setup.exe>");
        process::exit(1);
    };

    let data = fs::read(path).unwrap_or_else(|e| {
        eprintln!("error reading {path}: {e}");
        process::exit(1);
    });

    let installer = innospect::InnoInstaller::from_bytes(&data).unwrap_or_else(|e| {
        eprintln!("error parsing Inno Setup installer: {e}");
        process::exit(1);
    });

    let v = installer.version();
    println!("== Identification ==");
    println!("  marker:        {:?}", v.marker_str());
    println!("  version:       {}.{}.{}.{}", v.a, v.b, v.c, v.d);
    println!("  flags:         {:?}", v.flags);
    println!("  variant:       {:?}", installer.variant());
    println!(
        "  setupldr:      {:?} (locator: {:?})",
        installer.setup_ldr_family(),
        installer.pe_locator_mode(),
    );

    let ot = installer.offset_table();
    println!();
    println!("== Offset table ==");
    println!("  generation:    {:?}", ot.source.generation);
    println!("  version_id:    {}", ot.version_id);
    println!("  start:         {:#x}", ot.source.start);
    println!("  Offset0:       {:#x}", ot.offset_setup0);
    println!("  Offset1:       {:#x}", ot.offset_setup1);
    println!("  OffsetEXE:     {:#x}", ot.offset_exe);
    println!("  TotalSize:     {} bytes", ot.total_size);

    println!();
    println!("== Setup-0 ==");
    println!("  compression:   {:?}", installer.compression());
    println!(
        "  encryption:    {:?}",
        installer.encryption().map(|e| e.mode)
    );
    let setup0 = installer.decompressed_setup0();
    println!("  decompressed:  {} bytes", setup0.len());
    if !setup0.is_empty() {
        let preview_len = 128.min(setup0.len());
        let preview: Vec<u8> = setup0
            .iter()
            .take(preview_len)
            .map(|&b| if (32..127).contains(&b) { b } else { b'.' })
            .collect();
        println!("  preview:       {:?}", String::from_utf8_lossy(&preview));
    }

    if let Some(header) = installer.header() {
        println!();
        println!("== Setup header ==");
        println!("  AppName:        {:?}", header.app_name().unwrap_or(""));
        println!("  AppId:          {:?}", header.app_id().unwrap_or(""));
        println!("  AppVersion:     {:?}", header.app_version().unwrap_or(""));
        println!(
            "  AppPublisher:   {:?}",
            header.app_publisher().unwrap_or(""),
        );
    }
}
```
Tokens:
Raw