apeirogond 0.18.0

Daemon for Apeirogon, a cross-platform software KVM
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

// SPDX-License-Identifier: GPL-3.0-or-later

use super::*;

#[test]
fn verify_transfer_corrupt_or_out_of_order_frames_are_rejected() {
    // Arrange
    let item = ClipboardItem {
        size: 3,
        sha256: Sha256::digest(b"abc").to_vec(),
        ..ClipboardItem::default()
    };
    let cases = [
        vec![Frame::Chunk(FileChunk {
            file_index: 0,
            offset: 0,
            data: b"abcd".to_vec(),
        })],
        vec![Frame::Chunk(FileChunk {
            file_index: 0,
            offset: 1,
            data: b"abc".to_vec(),
        })],
        vec![Frame::Chunk(FileChunk {
            file_index: 1,
            offset: 0,
            data: b"abc".to_vec(),
        })],
        vec![Frame::Done(TransferDone {})],
        vec![Frame::FileEnd(FileEnd {
            file_index: 0,
            sha256: item.sha256.clone(),
        })],
        vec![
            Frame::Chunk(FileChunk {
                file_index: 0,
                offset: 0,
                data: b"bad".to_vec(),
            }),
            Frame::FileEnd(FileEnd {
                file_index: 0,
                sha256: item.sha256.clone(),
            }),
        ],
        vec![
            Frame::Chunk(FileChunk {
                file_index: 0,
                offset: 0,
                data: b"abc".to_vec(),
            }),
            Frame::FileEnd(FileEnd {
                file_index: 0,
                sha256: vec![0; 32],
            }),
        ],
    ];
    for frames in cases {
        let mut verifier = Verifier::new(&item).unwrap();

        // Act
        let result: Result<Vec<_>, _> = frames
            .into_iter()
            .map(|frame| verifier.apply(frame))
            .collect();

        // Assert
        assert!(result.is_err());
    }
}

#[tokio::test(start_paused = true)]
async fn receive_stalled_frame_returns_frame_timeout() {
    // Arrange
    let item = ClipboardItem {
        size: 3,
        ..ClipboardItem::default()
    };
    let mut stream = crate::frame::tests::StalledStream {
        prefix: Some(vec![1]),
        reads: 0,
    };
    let mut buf = Vec::new();
    let start = tokio::time::Instant::now();

    // Act
    let result = receive(&mut stream, &mut buf, &item).await;

    // Assert
    assert_eq!(result, Err(TransferError::Timeout));
    assert_eq!(start.elapsed(), limits::FRAME_READ_TIMEOUT);
}