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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::decode::DecodeLevel;
use crate::link::error::LinkError;
use crate::link::header::FrameInfo;
use crate::link::reader::LinkModes;
use crate::link::EndpointAddress;
use crate::outstation::Feature;
use crate::transport::{Fragment, FragmentAddr, FragmentInfo, TransportData};
use crate::util::buffer::Buffer;
use crate::util::phys::{PhysAddr, PhysLayer};

pub(crate) struct MockReader {
    num_reads: usize,
    count: usize,
    frame_id: u32,
    info: Option<FrameInfo>,
    buffer: Buffer,
}

impl MockReader {
    pub(crate) fn master(_: LinkModes, _: EndpointAddress, rx_buffer_size: usize) -> Self {
        Self::new(rx_buffer_size)
    }

    pub(crate) fn outstation(
        _: LinkModes,
        _: EndpointAddress,
        _self_address: Feature,
        rx_buffer_size: usize,
    ) -> Self {
        Self::new(rx_buffer_size)
    }

    fn new(buffer_size: usize) -> Self {
        Self {
            num_reads: 0,
            count: 0,
            frame_id: 0,
            info: None,
            buffer: Buffer::new(buffer_size),
        }
    }

    pub(crate) fn set_rx_frame_info(&mut self, info: FrameInfo) {
        self.info = Some(info)
    }

    pub(crate) fn num_reads(&self) -> usize {
        self.num_reads
    }

    pub(crate) fn reset(&mut self) {}

    pub(crate) fn seed_link(&mut self, _: &[u8]) -> Result<(), scursor::WriteError> {
        unimplemented!()
    }

    pub(crate) fn peek(&self) -> Option<TransportData> {
        Some(TransportData::Fragment(self.get(self.count)?))
    }

    pub(crate) fn pop(&mut self) -> Option<TransportData> {
        let count = self.count;
        self.count = 0;
        Some(TransportData::Fragment(self.get(count)?))
    }

    fn get(&self, count: usize) -> Option<Fragment> {
        if count == 0 {
            return None;
        }
        let info = self
            .info
            .expect("call set_rx_frame_info(..) before running test");
        let addr = FragmentAddr {
            link: info.source,
            phys: PhysAddr::None,
        };
        let fragment = Fragment {
            info: FragmentInfo::new(self.frame_id, addr, info.broadcast),
            data: self.buffer.get(count).unwrap(),
        };
        Some(fragment)
    }

    pub(crate) async fn read(
        &mut self,
        io: &mut PhysLayer,
        level: DecodeLevel,
    ) -> Result<(), LinkError> {
        if self.count > 0 {
            return Ok(());
        }

        self.num_reads += 1;
        let (count, _) = io
            .read(
                self.buffer.get_mut(self.buffer.len()).unwrap(),
                level.physical,
            )
            .await?;
        self.count = count;
        self.frame_id = self.frame_id.wrapping_add(1);
        Ok(())
    }
}