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
106

use crate::app::parse::parser::{Request, Response};
use crate::app::{HeaderParseError, RequestValidationError, ResponseValidationError, Sequence};
use crate::link::header::BroadcastConfirmMode;
use crate::link::EndpointAddress;
use crate::util::phys::PhysAddr;

#[derive(Debug, Copy, Clone)]
pub(crate) struct FragmentAddr {
    /// remote link address
    pub(crate) link: EndpointAddress,
    /// remote physical-layer address
    pub(crate) phys: PhysAddr,
}

#[derive(Debug, Copy, Clone)]
pub(crate) struct FragmentInfo {
    pub(crate) id: u32,
    pub(crate) addr: FragmentAddr,
    pub(crate) broadcast: Option<BroadcastConfirmMode>,
}

impl FragmentInfo {
    pub(crate) fn new(
        id: u32,
        addr: FragmentAddr,
        broadcast: Option<BroadcastConfirmMode>,
    ) -> Self {
        FragmentInfo {
            id,
            addr,
            broadcast,
        }
    }
}

#[derive(Debug)]
pub(crate) struct Fragment<'a> {
    pub(crate) info: FragmentInfo,
    pub(crate) data: &'a [u8],
}

#[derive(Debug)]
pub(crate) enum TransportData<'a> {
    Fragment(Fragment<'a>),
    LinkLayerMessage(LinkLayerMessage),
}

#[derive(Debug, Copy, Clone, PartialEq)]
pub(crate) struct LinkLayerMessage {
    pub(crate) source: EndpointAddress,
    pub(crate) message: LinkLayerMessageType,
}

#[derive(Debug, Copy, Clone, PartialEq)]
pub(crate) enum LinkLayerMessageType {
    LinkStatusRequest,
    LinkStatusResponse,
}

pub(crate) enum TransportResponse<'a> {
    Response(FragmentAddr, Response<'a>),
    LinkLayerMessage(LinkLayerMessage),
    Error(TransportResponseError),
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub(crate) enum TransportResponseError {
    HeaderParseError(HeaderParseError),
    ResponseValidationError(ResponseValidationError),
}

impl From<HeaderParseError> for TransportResponseError {
    fn from(from: HeaderParseError) -> Self {
        Self::HeaderParseError(from)
    }
}

impl From<ResponseValidationError> for TransportResponseError {
    fn from(from: ResponseValidationError) -> Self {
        Self::ResponseValidationError(from)
    }
}

pub(crate) enum TransportRequest<'a> {
    Request(FragmentInfo, Request<'a>),
    LinkLayerMessage,
    Error(FragmentAddr, TransportRequestError),
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub(crate) enum TransportRequestError {
    HeaderParseError(HeaderParseError),
    RequestValidationError(Sequence, RequestValidationError),
}

impl RequestValidationError {
    pub(crate) fn into(self, seq: Sequence) -> TransportRequestError {
        TransportRequestError::RequestValidationError(seq, self)
    }
}

impl From<HeaderParseError> for TransportRequestError {
    fn from(from: HeaderParseError) -> Self {
        Self::HeaderParseError(from)
    }
}