inno 0.4.2

Library for reading Inno Setup executables
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::io::{Error, ErrorKind, Read, Result, Take};

use flate2::read::ZlibDecoder;
use liblzma::read::XzDecoder;
use zerocopy::LE;

use crate::{
    ReadBytesExt,
    compression::Compression,
    error::InnoError,
    lzma_stream_header::LzmaStreamHeader,
    read::{
        block::{INNO_BLOCK_SIZE, InnoBlockReader},
        crc32::Crc32Reader,
        decoder::Decoder,
    },
    version::InnoVersion,
};

pub struct InnoStreamReader<R: Read> {
    inner: Decoder<InnoBlockReader<Take<R>>>,
    compression: Compression,
    inno_version: InnoVersion,
}

impl<R: Read> InnoStreamReader<R> {
    pub fn new(mut inner: R, version: InnoVersion) -> Result<Self> {
        let compression = Self::read_header(&mut inner, version)?;

        let mut chunk_reader = InnoBlockReader::new(inner.take(compression.size()));

        Ok(Self {
            inner: match compression {
                Compression::LZMA1(_) => {
                    let stream = LzmaStreamHeader::read(&mut chunk_reader)?;
                    Decoder::LZMA1(XzDecoder::new_stream(chunk_reader, stream))
                }
                Compression::Zlib(_) => Decoder::Zlib(ZlibDecoder::new(chunk_reader)),
                Compression::Stored(_) => Decoder::Stored(chunk_reader),
            },
            compression,
            inno_version: version,
        })
    }

    fn read_header(reader: &mut R, version: InnoVersion) -> Result<Compression> {
        let expected_crc32 = reader.read_u32::<LE>()?;

        let mut crc32_reader = Crc32Reader::new(reader);

        let compression = if version >= (4, 0, 9) {
            let size = if version >= 6.7 {
                crc32_reader.read_u64::<LE>()?
            } else {
                crc32_reader.read_u32::<LE>()?.into()
            };
            let compressed = crc32_reader.read_u8()? != 0;

            if compressed {
                if version >= (4, 1, 6) {
                    Compression::LZMA1(size)
                } else {
                    Compression::Zlib(size)
                }
            } else {
                Compression::Stored(size)
            }
        } else {
            let compressed_size = crc32_reader.read_u32::<LE>()?;
            let uncompressed_size = crc32_reader.read_u32::<LE>()?;

            let mut compression = if compressed_size.cast_signed() == -1 {
                Compression::Stored(uncompressed_size.into())
            } else {
                Compression::Zlib(compressed_size.into())
            };

            // Add the size of a CRC32 checksum for each 4KiB sub-block
            *compression.size_mut() += compression.size().div_ceil(INNO_BLOCK_SIZE.into()) * 4;

            compression
        };

        let actual_crc32 = crc32_reader.finalize();
        if actual_crc32 != expected_crc32 {
            return Err(Error::new(
                ErrorKind::InvalidData,
                InnoError::CrcChecksumMismatch {
                    location: "Inno stream header",
                    actual: actual_crc32,
                    expected: expected_crc32,
                },
            ));
        }

        Ok(compression)
    }

    /// Consumes the stream reader and returns a new one.
    pub fn reset(self) -> Result<Self> {
        let version = self.inno_version;
        let reader = self
            .into_inner() // Decoder<InnoBlockReader<Take<R>>>
            .into_inner() // InnoBlockReader<Take<R>>
            .into_inner() // Take<R>
            .into_inner(); // R
        Self::new(reader, version)
    }

    /// Gets a reference to the underlying reader.
    ///
    /// It is inadvisable to directly read from the underlying reader.
    #[must_use]
    #[inline]
    pub const fn get_ref(&self) -> &Decoder<InnoBlockReader<Take<R>>> {
        &self.inner
    }

    /// Gets a mutable reference to the underlying reader.
    ///
    /// It is inadvisable to directly read from the underlying reader.
    #[must_use]
    #[inline]
    pub const fn get_mut(&mut self) -> &mut Decoder<InnoBlockReader<Take<R>>> {
        &mut self.inner
    }

    /// Consumes this stream reader, returning the underlying reader.
    #[must_use]
    #[inline]
    pub fn into_inner(self) -> Decoder<InnoBlockReader<Take<R>>> {
        self.inner
    }

    /// Returns true if the reader is at the end of the stream.
    ///
    /// This means that the number of compressed bytes specified in the stream header has been read.
    #[must_use]
    pub fn is_end_of_stream(&self) -> bool {
        self.get_ref().get_ref().total_in() == self.compression.size() as usize
    }
}

impl<R: Read> Read for InnoStreamReader<R> {
    fn read(&mut self, dest: &mut [u8]) -> Result<usize> {
        self.inner.read(dest)
    }
}