dnp3 1.6.0

Rust implementation of DNP3 (IEEE 1815) with idiomatic bindings for C, C++, .NET, and Java
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

use crate::app::format::free_format::FreeFormat;
use crate::app::format::write::HeaderWriter;
use crate::app::format::WriteError;
use crate::app::{FileStatus, FunctionCode, Group70Var4, Group70Var5, Group70Var6, Variation};
use scursor::WriteCursor;

mod close_file;
mod open_file;
mod read_file;

impl<'a> FreeFormat for Group70Var6<'a> {
    const VARIATION: Variation = Variation::Group70Var6;

    fn write(&self, cursor: &mut WriteCursor) -> Result<(), WriteError> {
        self.write(cursor)
    }
}

pub(super) fn last_block(block: u32) -> u32 {
    1 << 31 | block
}

pub(super) fn fir_and_fin(seq: u8) -> u8 {
    0b1100_0000 | seq
}

pub(super) fn file_status_response(
    seq: u8,
    file_handle: u32,
    file_size: u32,
    max_block_size: u16,
    status_code: FileStatus,
) -> Vec<u8> {
    response(
        seq,
        &Group70Var4 {
            file_handle,
            file_size,
            max_block_size,
            request_id: 0,
            status_code,
            text: "",
        },
    )
}

pub(super) fn file_transport_response(
    seq: u8,
    file_handle: u32,
    block_number: u32,
    file_data: &[u8],
) -> Vec<u8> {
    response(
        seq,
        &Group70Var5 {
            file_handle,
            block_number,
            file_data,
        },
    )
}

pub(crate) fn response<T: FreeFormat>(seq: u8, variation: &T) -> Vec<u8> {
    let mut response = [fir_and_fin(seq), 0x81, 0x00, 0x00].to_vec();

    let mut buffer: [u8; 64] = [0; 64];
    let mut cursor = WriteCursor::new(&mut buffer);
    let mut writer = HeaderWriter::new(&mut cursor);
    writer.write_free_format(variation).unwrap();

    response.extend_from_slice(cursor.written());

    response
}

pub(crate) fn request<T: FreeFormat>(function: FunctionCode, seq: u8, variation: &T) -> Vec<u8> {
    let mut response = [fir_and_fin(seq), function.as_u8()].to_vec();

    let mut buffer: [u8; 64] = [0; 64];
    let mut cursor = WriteCursor::new(&mut buffer);
    let mut writer = HeaderWriter::new(&mut cursor);
    writer.write_free_format(variation).unwrap();

    response.extend_from_slice(cursor.written());

    response
}