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

use std::io;

use zerocopy::LE;

use crate::{ReadBytesExt, version::InnoVersion};

#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
struct Version {
    major: u8,
    minor: u8,
    build: u16,
}

impl Version {
    /// Returns the major version number.
    #[must_use]
    #[inline]
    pub const fn major(self) -> u8 {
        self.major
    }

    /// Returns the minor version number.
    #[must_use]
    #[inline]
    pub const fn minor(self) -> u8 {
        self.minor
    }

    /// Returns the build number.
    #[must_use]
    #[inline]
    pub const fn build(self) -> u16 {
        self.build
    }

    fn read<R>(reader: &mut R, inno_version: InnoVersion) -> io::Result<Self>
    where
        R: io::Read,
    {
        let mut version = Self::default();

        if inno_version >= (1, 3, 19) {
            version.build = reader.read_u16::<LE>()?;
        }
        version.minor = reader.read_u8()?;
        version.major = reader.read_u8()?;

        Ok(version)
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
struct ServicePack {
    major: u8,
    minor: u8,
}

#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
struct WindowsVersion {
    pub win_version: Version,
    pub nt_version: Version,
    pub nt_service_pack: ServicePack,
}

impl WindowsVersion {
    pub fn read_from<R>(src: &mut R, version: InnoVersion) -> io::Result<Self>
    where
        R: io::Read,
    {
        let mut windows_version = Self {
            win_version: Version::read(src, version)?,
            nt_version: Version::read(src, version)?,
            ..Self::default()
        };

        if version >= (1, 3, 19) {
            windows_version.nt_service_pack.minor = src.read_u8()?;
            windows_version.nt_service_pack.major = src.read_u8()?;
        }

        Ok(windows_version)
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
pub struct WindowsVersionRange {
    begin: WindowsVersion,
    end: WindowsVersion,
}

impl WindowsVersionRange {
    pub fn read_from<R>(src: &mut R, version: InnoVersion) -> io::Result<Self>
    where
        R: io::Read,
    {
        Ok(Self {
            begin: WindowsVersion::read_from(src, version)?,
            end: WindowsVersion::read_from(src, version)?,
        })
    }
}