lnk 0.6.4

A Rust library to parse and write Windows shortcut files (.lnk)
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

use std::fmt;

use binrw::{BinRead, BinReaderExt, BinWrite};
use chrono::NaiveDateTime;

#[cfg(feature = "serde")]
use serde::Serialize;
use winstructs::timestamp::WinTimestamp;

/// The FILETIME structure is a 64-bit value that represents the number of
/// 100-nanosecond intervals that have elapsed since January 1, 1601,
/// Coordinated Universal Time (UTC).
#[derive(Clone)]
pub struct FileTime(WinTimestamp, u64);

impl fmt::Debug for FileTime {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.datetime())
    }
}

impl BinRead for FileTime {
    type Args<'a> = ();

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        _endian: binrw::Endian,
        _args: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        let pos = reader.stream_position()?;
        let raw: u64 = reader.read_le()?;

        match WinTimestamp::new(&raw.to_le_bytes()) {
            Ok(timestamp) => Ok(Self(timestamp, raw)),
            Err(why) => Err(binrw::Error::AssertFail {
                pos,
                message: format!("{why}"),
            }),
        }
    }
}

impl BinWrite for FileTime {
    type Args<'a> = ();

    fn write_options<W: std::io::Write + std::io::Seek>(
        &self,
        writer: &mut W,
        _endian: binrw::Endian,
        _args: Self::Args<'_>,
    ) -> binrw::BinResult<()> {
        self.1.write_le(writer)
    }
}

#[cfg(feature = "serde")]
impl Serialize for FileTime {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&format!("{}", self.0))
    }
}

impl FileTime {
    /// Convert the `FileTime` object to a [[]]
    pub fn datetime(&self) -> NaiveDateTime {
        self.0.to_datetime().naive_utc()
    }

    /*
    /// Create a new `FileTime` object representing now.
    pub fn now() -> Self {
        Self::from(chrono::Local::now().naive_local())
    }
     */
}

impl Default for FileTime {
    fn default() -> Self {
        let raw = 0u64;
        let timestamp = WinTimestamp::new(&raw.to_le_bytes()).unwrap();
        Self(timestamp, raw)
    }
}

/*
impl From<NaiveDateTime> for FileTime {
    fn from(value: NaiveDateTime) -> Self {
        let duration = value - Self::epoch();
        let val = duration.num_microseconds().unwrap() * 10;
        let val = val as u64;
        Self::from(val)
    }
}
 */

impl From<FileTime> for u64 {
    fn from(val: FileTime) -> Self {
        val.1
    }
}

#[cfg(test)]
mod tests {
    use std::io::Cursor;

    use binrw::{BinReaderExt, BinWrite};
    use winstructs::timestamp::WinTimestamp;

    use super::FileTime;

    #[test]
    fn test_guid_be() {
        let mut cursor = Cursor::new([0u8; 16]);
        let input = test_data();

        input.write_be(&mut cursor).unwrap();
        cursor.set_position(0);
        let output: FileTime = cursor.read_be().unwrap();
        assert_eq!(input.0.to_datetime(), output.0.to_datetime());
        assert_eq!(input.1, output.1);
    }

    #[test]
    fn test_guid_le() {
        let mut cursor = Cursor::new([0u8; 16]);
        let input = test_data();

        input.write_le(&mut cursor).unwrap();
        cursor.set_position(0);
        let output: FileTime = cursor.read_le().unwrap();
        assert_eq!(input.0.to_datetime(), output.0.to_datetime());
        assert_eq!(input.1, output.1);
    }

    fn test_data() -> FileTime {
        let raw = 123456789000u64;
        let timestamp = WinTimestamp::new(&raw.to_le_bytes()).unwrap();
        FileTime(timestamp, raw)
    }
}